@plait/mind 0.8.0 → 0.10.0

package/README.md

@@ -1,24 +1,143 @@
-# mindmap
 
-This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.3.0.
 
-## Code scaffolding
+@plait/mind 库包含思维导图的核心逻辑的实现，基于 Plait 框架，是最早也是目前唯一一个落地的业务插件。
 
-Run `ng generate component component-name --project mindmap` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project mindmap`.
-> Note: Don't forget to add `--project mindmap` or else it will be added to the default project in your `angular.json` file. 
 
-## Build
 
-Run `ng build mindmap` to build the project. The build artifacts will be stored in the `dist/` directory.
+**基础功能**
 
-## Publishing
+1. 支持逻辑布局、标准布局、缩进布局
+1. 节点快捷新建（Tab、Enter）、删除（Delete、Backspace）
+1. 节点主题文本编辑
+1. 节点展开收起
+1. 节点复制、粘贴
 
-After building your library with `ng build mindmap`, go to the dist folder `cd dist/mind` and run `npm publish`.
 
-## Running unit tests
 
-Run `ng test mindmap` to execute the unit tests via [Karma](https://karma-runner.github.io).
 
-## Further help
+**高阶功能**
+
+1. 节点支持拖拽调整位置
+1. 节点支持概要/调整概要范围
+1. 节点支持扩展设置 Emoji 表情
+1. 交互式创建思维导图插件
+
+
+
+
+**功能演示**
+
+
+
+
+
+@plait/mind 核心仅仅包含数据渲染及核心交互实现，不包含工具栏、属性设置等基于界面的交互实现，因为这部分功能依赖于特定的界面风格（插件层不希望引入组件库），我们在设计上倾向于把这部分功能交由使用方自定义实现，插件层只提供事件支持及个性化配置支持。
+
+
+
+**自定义扩展**
+
+
+
+1. 支持 MindOptions 配置
+
+提供 Mind 插件特有的可重写函数，用于使用方自定义 Mind 插件配置（控制渲染样式、交互风格等）：
+
+```
+export interface MindOptions {
+    emojiPadding: number;
+    spaceBetweenEmojis: number;
+}
+```
+
+目前仅支持 emoji 扩展相关的自定义配置，后续会把节点之间的间隙、文本与节点之间的间隙等等做成自定义配置，目前这些配置是按照我们自己的需求固定在代码中的。
+
+
+
+2. 支持扩展 Emoji
+
+Mind 插件支持 Emoji 功能的时候仅仅提供了一个调用入口，需要使用方提供具体的一个 Emoji 渲染组件，用于具体的实现 Emoji 的渲染及交互，插件层不关注 Emoji 的交互细节、也不管理 Emoji 资源，仅仅控制 emoji 的渲染位置及空间占位。
+
+提供可重写函数签名：
+
+```
+drawEmoji: (emoji: EmojiItem, element: MindElement) => ComponentType<MindEmojiBaseComponent>;
+```
+
+提供 Emoji 渲染组件基类：
+
+```
+@Directive({
+    host: {
+        class: 'mind-node-emoji'
+    }
+})
+export class MindEmojiBaseComponent implements OnInit {
+    @Input()
+    fontSize: number = 14;
+
+    @Input()
+    emojiItem!: EmojiItem;
+
+    @Input()
+    board!: PlaitBoard;
+
+    @Input()
+    element!: MindElement<EmojiData>;
+
+    get nativeElement() {
+        return this.elementRef.nativeElement;
+    }
+
+    constructor(protected elementRef: ElementRef<HTMLElement>) {}
+
+    ngOnInit(): void {
+        this.elementRef.nativeElement.style.fontSize = `${this.fontSize}px`;
+    }
+}
+```
+
+不同提供默认实现
+
+```
+newBoard.drawEmoji = (emoji: EmojiItem, element: MindElement) => {
+  throw new Error('Not implement drawEmoji method error.');
+};
+```
+
+
+
+3. 概要调整
+
+因为业务方需要在概要拖拽调整范围时做一定的业务处理，所以插件层增加了一个可重写方法用于抛出概要调整时的状态
+
+提供可选的可重写函数签名 onAbstractResize： 
+
+```
+export interface PlaitAbstractBoard extends PlaitBoard {
+    onAbstractResize?: (state: AbstractResizeState) => void;
+}
+```
+
+AbstractResizeState 状态定义：
+
+```
+export enum AbstractResizeState {
+    start = 'start',
+    resizing = 'resizing',
+    end = 'end'
+}
+```
+
+
+
+**依赖**
+
+@plait/core
+
+@plait/layouts
+
+@plait/richtext
+
+
 
-To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/base/base.drawer.d.ts

@@ -1,11 +1,12 @@
 import { PlaitBoard } from '@plait/core';
 import { MindElement } from '../interfaces';
-export declare abstract class BaseDrawer {
+export declare abstract class BaseDrawer<T = undefined> {
     protected board: PlaitBoard;
     g?: SVGGElement;
     constructor(board: PlaitBoard);
-    abstract canDraw(element: MindElement): boolean;
-    abstract draw(element: MindElement): SVGGElement | undefined;
+    draw(element: MindElement, parentG: SVGGElement, data?: T): void;
+    abstract canDraw(element: MindElement, data?: T): boolean;
+    abstract baseDraw(element: MindElement, data?: T): SVGGElement | undefined;
     destroy(): void;
 }
 export interface AfterDraw {

package/constants/default.d.ts

@@ -5,7 +5,7 @@ export declare const GRAY_COLOR = "#AAAAAA";
 export declare const STROKE_WIDTH = 3;
 export declare const BRANCH_WIDTH = 3;
 export declare const EXTEND_OFFSET = 8;
-export declare const EXTEND_RADIUS = 16;
+export declare const EXTEND_DIAMETER = 16;
 export declare const QUICK_INSERT_CIRCLE_OFFSET = 9;
 export declare const QUICK_INSERT_CIRCLE_COLOR = "#6698FF";
 export declare const QUICK_INSERT_INNER_CROSS_COLOR = "white";

package/constants/node-topic-style.d.ts

@@ -1,4 +1,5 @@
 export declare const TOPIC_COLOR = "#333";
 export declare const TOPIC_FONT_SIZE = 14;
 export declare const ROOT_TOPIC_FONT_SIZE = 18;
+export declare const ROOT_TOPIC_HEIGHT = 25;
 export declare const TOPIC_DEFAULT_MAX_WORD_COUNT = 34;

package/drawer/node-active.drawer.d.ts

@@ -0,0 +1,13 @@
+import { MindElement, BaseData } from '../interfaces';
+import { BaseDrawer } from '../base/base.drawer';
+import { AbstractHandlePosition } from '../plugins/with-abstract-resize.board';
+export interface ActiveData {
+    selected: boolean;
+    isEditing: boolean;
+}
+export declare class NodeActiveDrawer extends BaseDrawer<ActiveData> {
+    abstractOutlineG?: SVGGElement;
+    canDraw(element: MindElement<BaseData>, data: ActiveData): boolean;
+    baseDraw(element: MindElement<BaseData>, data: ActiveData): SVGGElement;
+    updateAbstractOutline(element: MindElement, activeHandlePosition?: AbstractHandlePosition, resizingLocation?: number): void;
+}

package/drawer/node-collapse.drawer.d.ts

@@ -0,0 +1,8 @@
+import { MindElement, BaseData } from '../interfaces';
+import { AfterDraw, BaseDrawer } from '../base/base.drawer';
+export declare class CollapseDrawer extends BaseDrawer implements AfterDraw {
+    canDraw(element: MindElement<BaseData>): boolean;
+    baseDraw(element: MindElement<BaseData>): SVGGElement;
+    afterDraw(element: MindElement): void;
+    private getArrowPoints;
+}

package/drawer/{emojis.drawer.d.ts → node-emojis.drawer.d.ts}

@@ -11,7 +11,7 @@ declare class EmojiDrawer {
     get nativeElement(): HTMLElement | null;
     destroy(): void;
 }
-export declare class EmojisDrawer {
+export declare class NodeEmojisDrawer {
     private board;
     private viewContainerRef;
     emojiDrawers: EmojiDrawer[];

package/drawer/{quick-insert.drawer.d.ts → node-insert.drawer.d.ts}

@@ -1,7 +1,7 @@
 import { MindElement, BaseData } from '../interfaces';
 import { AfterDraw, BaseDrawer } from '../base/base.drawer';
-export declare class QuickInsertDrawer extends BaseDrawer implements AfterDraw {
+export declare class NodeInsertDrawer extends BaseDrawer implements AfterDraw {
     canDraw(element: MindElement<BaseData>): boolean;
-    draw(element: MindElement<BaseData>): SVGGElement;
+    baseDraw(element: MindElement<BaseData>): SVGGElement;
     afterDraw(element: MindElement): void;
 }

package/esm2020/base/base.drawer.mjs

@@ -2,6 +2,18 @@ export class BaseDrawer {
     constructor(board) {
         this.board = board;
     }
+    draw(element, parentG, data) {
+        this.destroy();
+        if (this.canDraw && this.canDraw(element, data)) {
+            const g = this.baseDraw(element, data);
+            if (g) {
+                parentG.append(g);
+            }
+            if (hasAfterDraw(this)) {
+                this.afterDraw(element);
+            }
+        }
+    }
     destroy() {
         if (this.g) {
             this.g.remove();
@@ -14,4 +26,4 @@ export function hasAfterDraw(value) {
     }
     return false;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5kcmF3ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9taW5kL3NyYy9iYXNlL2Jhc2UuZHJhd2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBZ0IsVUFBVTtJQUc1QixZQUFzQixLQUFpQjtRQUFqQixVQUFLLEdBQUwsS0FBSyxDQUFZO0lBQUcsQ0FBQztJQU0zQyxPQUFPO1FBQ0gsSUFBSSxJQUFJLENBQUMsQ0FBQyxFQUFFO1lBQ1IsSUFBSSxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztTQUNuQjtJQUNMLENBQUM7Q0FDSjtBQU1ELE1BQU0sVUFBVSxZQUFZLENBQUMsS0FBVTtJQUNuQyxJQUFJLEtBQUssQ0FBQyxTQUFTLEVBQUU7UUFDakIsT0FBTyxJQUFJLENBQUM7S0FDZjtJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2pCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQbGFpdEJvYXJkIH0gZnJvbSAnQHBsYWl0L2NvcmUnO1xuaW1wb3J0IHsgTWluZEVsZW1lbnQgfSBmcm9tICcuLi9pbnRlcmZhY2VzJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEJhc2VEcmF3ZXIge1xuICAgIGc/OiBTVkdHRWxlbWVudDtcblxuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBib2FyZDogUGxhaXRCb2FyZCkge31cblxuICAgIGFic3RyYWN0IGNhbkRyYXcoZWxlbWVudDogTWluZEVsZW1lbnQpOiBib29sZWFuO1xuXG4gICAgYWJzdHJhY3QgZHJhdyhlbGVtZW50OiBNaW5kRWxlbWVudCk6IFNWR0dFbGVtZW50IHwgdW5kZWZpbmVkO1xuXG4gICAgZGVzdHJveSgpIHtcbiAgICAgICAgaWYgKHRoaXMuZykge1xuICAgICAgICAgICAgdGhpcy5nLnJlbW92ZSgpO1xuICAgICAgICB9XG4gICAgfVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIEFmdGVyRHJhdyB7XG4gICAgYWZ0ZXJEcmF3KGVsZW1lbnQ6IE1pbmRFbGVtZW50KTogdm9pZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGhhc0FmdGVyRHJhdyh2YWx1ZTogYW55KTogdmFsdWUgaXMgQWZ0ZXJEcmF3IHtcbiAgICBpZiAodmFsdWUuYWZ0ZXJEcmF3KSB7XG4gICAgICAgIHJldHVybiB0cnVlO1xuICAgIH1cbiAgICByZXR1cm4gZmFsc2U7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/constants/default.mjs

@@ -5,8 +5,8 @@ export const GRAY_COLOR = '#AAAAAA';
 export const STROKE_WIDTH = 3;
 export const BRANCH_WIDTH = 3;
 export const EXTEND_OFFSET = 8;
-export const EXTEND_RADIUS = 16;
+export const EXTEND_DIAMETER = 16;
 export const QUICK_INSERT_CIRCLE_OFFSET = 9;
 export const QUICK_INSERT_CIRCLE_COLOR = '#6698FF';
 export const QUICK_INSERT_INNER_CROSS_COLOR = 'white';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21pbmQvc3JjL2NvbnN0YW50cy9kZWZhdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxDQUFDLENBQUM7QUFDdEIsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FBQztBQUV2QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsYUFBYSxDQUFDO0FBQ3pDLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUM7QUFDcEMsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsQ0FBQztBQUM5QixNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxDQUFDO0FBRTlCLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUFDLENBQUM7QUFDL0IsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEVBQUUsQ0FBQztBQUVoQyxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxDQUFDLENBQUM7QUFDNUMsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsU0FBUyxDQUFDO0FBQ25ELE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBCQVNFID0gNDtcbmV4cG9ydCBjb25zdCBQUklNQVJZX0NPTE9SID0gJyM2Njk4RkYnO1xuXG5leHBvcnQgY29uc3QgVFJBTlNQQVJFTlQgPSAndHJhbnNwYXJlbnQnO1xuZXhwb3J0IGNvbnN0IEdSQVlfQ09MT1IgPSAnI0FBQUFBQSc7XG5leHBvcnQgY29uc3QgU1RST0tFX1dJRFRIID0gMztcbmV4cG9ydCBjb25zdCBCUkFOQ0hfV0lEVEggPSAzO1xuXG5leHBvcnQgY29uc3QgRVhURU5EX09GRlNFVCA9IDg7XG5leHBvcnQgY29uc3QgRVhURU5EX1JBRElVUyA9IDE2O1xuXG5leHBvcnQgY29uc3QgUVVJQ0tfSU5TRVJUX0NJUkNMRV9PRkZTRVQgPSA5O1xuZXhwb3J0IGNvbnN0IFFVSUNLX0lOU0VSVF9DSVJDTEVfQ09MT1IgPSAnIzY2OThGRic7XG5leHBvcnQgY29uc3QgUVVJQ0tfSU5TRVJUX0lOTkVSX0NST1NTX0NPTE9SID0gJ3doaXRlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21pbmQvc3JjL2NvbnN0YW50cy9kZWZhdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxDQUFDLENBQUM7QUFDdEIsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FBQztBQUV2QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsYUFBYSxDQUFDO0FBQ3pDLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUM7QUFDcEMsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsQ0FBQztBQUM5QixNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxDQUFDO0FBRTlCLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUFDLENBQUM7QUFDL0IsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLEVBQUUsQ0FBQztBQUVsQyxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxDQUFDLENBQUM7QUFDNUMsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsU0FBUyxDQUFDO0FBQ25ELE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBCQVNFID0gNDtcbmV4cG9ydCBjb25zdCBQUklNQVJZX0NPTE9SID0gJyM2Njk4RkYnO1xuXG5leHBvcnQgY29uc3QgVFJBTlNQQVJFTlQgPSAndHJhbnNwYXJlbnQnO1xuZXhwb3J0IGNvbnN0IEdSQVlfQ09MT1IgPSAnI0FBQUFBQSc7XG5leHBvcnQgY29uc3QgU1RST0tFX1dJRFRIID0gMztcbmV4cG9ydCBjb25zdCBCUkFOQ0hfV0lEVEggPSAzO1xuXG5leHBvcnQgY29uc3QgRVhURU5EX09GRlNFVCA9IDg7XG5leHBvcnQgY29uc3QgRVhURU5EX0RJQU1FVEVSID0gMTY7XG5cbmV4cG9ydCBjb25zdCBRVUlDS19JTlNFUlRfQ0lSQ0xFX09GRlNFVCA9IDk7XG5leHBvcnQgY29uc3QgUVVJQ0tfSU5TRVJUX0NJUkNMRV9DT0xPUiA9ICcjNjY5OEZGJztcbmV4cG9ydCBjb25zdCBRVUlDS19JTlNFUlRfSU5ORVJfQ1JPU1NfQ09MT1IgPSAnd2hpdGUnO1xuIl19

package/esm2020/constants/node-rule.mjs

@@ -1,2 +1,2 @@
 export const NODE_MIN_WIDTH = 18;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1ydWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvbWluZC9zcmMvY29uc3RhbnRzL25vZGUtcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IE5PREVfTUlOX1dJRFRIID0gMTg7Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1ydWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvbWluZC9zcmMvY29uc3RhbnRzL25vZGUtcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IE5PREVfTUlOX1dJRFRIID0gMTg7XG4iXX0=

package/esm2020/constants/node-topic-style.mjs

@@ -1,5 +1,6 @@
 export const TOPIC_COLOR = '#333';
 export const TOPIC_FONT_SIZE = 14;
 export const ROOT_TOPIC_FONT_SIZE = 18;
+export const ROOT_TOPIC_HEIGHT = 25;
 export const TOPIC_DEFAULT_MAX_WORD_COUNT = 34;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS10b3BpYy1zdHlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21pbmQvc3JjL2NvbnN0YW50cy9ub2RlLXRvcGljLXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUM7QUFDbEMsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLEVBQUUsQ0FBQztBQUVsQyxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxFQUFFLENBQUM7QUFFdkMsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQUcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFRPUElDX0NPTE9SID0gJyMzMzMnO1xuZXhwb3J0IGNvbnN0IFRPUElDX0ZPTlRfU0laRSA9IDE0O1xuXG5leHBvcnQgY29uc3QgUk9PVF9UT1BJQ19GT05UX1NJWkUgPSAxODtcblxuZXhwb3J0IGNvbnN0IFRPUElDX0RFRkFVTFRfTUFYX1dPUkRfQ09VTlQgPSAzNDsiXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS10b3BpYy1zdHlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21pbmQvc3JjL2NvbnN0YW50cy9ub2RlLXRvcGljLXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUM7QUFDbEMsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLEVBQUUsQ0FBQztBQUVsQyxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxFQUFFLENBQUM7QUFFdkMsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsRUFBRSxDQUFDO0FBRXBDLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUFHLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBUT1BJQ19DT0xPUiA9ICcjMzMzJztcbmV4cG9ydCBjb25zdCBUT1BJQ19GT05UX1NJWkUgPSAxNDtcblxuZXhwb3J0IGNvbnN0IFJPT1RfVE9QSUNfRk9OVF9TSVpFID0gMTg7XG5cbmV4cG9ydCBjb25zdCBST09UX1RPUElDX0hFSUdIVCA9IDI1O1xuXG5leHBvcnQgY29uc3QgVE9QSUNfREVGQVVMVF9NQVhfV09SRF9DT1VOVCA9IDM0OyJdfQ==

package/esm2020/drawer/node-active.drawer.mjs

@@ -0,0 +1,43 @@
+import { PlaitBoard, createG, drawRoundRectangle } from '@plait/core';
+import { MindElement } from '../interfaces';
+import { BaseDrawer } from '../base/base.drawer';
+import { getRectangleByNode } from '../utils/position/node';
+import { PRIMARY_COLOR } from '../constants/default';
+import { AbstractNode } from '@plait/layouts';
+import { drawAbstractIncludedOutline } from '../utils/draw/abstract-outline';
+export class NodeActiveDrawer extends BaseDrawer {
+    canDraw(element, data) {
+        if (data.selected) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    baseDraw(element, data) {
+        const activeG = createG();
+        this.g = activeG;
+        if (AbstractNode.isAbstract(element)) {
+            this.abstractOutlineG = drawAbstractIncludedOutline(this.board, PlaitBoard.getRoughSVG(this.board), element);
+            activeG.append(this.abstractOutlineG);
+        }
+        const node = MindElement.getNode(element);
+        let { x, y, width, height } = getRectangleByNode(node);
+        const strokeG = drawRoundRectangle(PlaitBoard.getRoughSVG(this.board), x - 2, y - 2, x + width + 2, y + height + 2, { stroke: PRIMARY_COLOR, strokeWidth: 2, fill: '' }, true);
+        this.g.appendChild(strokeG);
+        if (!data.isEditing) {
+            const fillG = drawRoundRectangle(PlaitBoard.getRoughSVG(this.board), x - 2, y - 2, x + width + 2, y + height + 2, { stroke: PRIMARY_COLOR, fill: PRIMARY_COLOR, fillStyle: 'solid' }, true);
+            fillG.style.opacity = '0.15';
+            this.g.appendChild(fillG);
+        }
+        return activeG;
+    }
+    updateAbstractOutline(element, activeHandlePosition, resizingLocation) {
+        if (this.abstractOutlineG) {
+            this.abstractOutlineG.remove();
+        }
+        this.abstractOutlineG = drawAbstractIncludedOutline(this.board, PlaitBoard.getRoughSVG(this.board), element, activeHandlePosition, resizingLocation);
+        this.g.append(this.abstractOutlineG);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/drawer/node-collapse.drawer.mjs

@@ -0,0 +1,108 @@
+import { PlaitBoard, PlaitPointerType, Transforms, createG, createText, drawLinearPath } from '@plait/core';
+import { MindElement, PlaitMind, MindElementShape, LayoutDirection } from '../interfaces';
+import { BaseDrawer } from '../base/base.drawer';
+import { getRectangleByNode } from '../utils/position/node';
+import { getShapeByElement } from '../utils/node-style/shape';
+import { EXTEND_OFFSET, EXTEND_DIAMETER } from '../constants/default';
+import { isHorizontalLayout, isIndentedLayout, isTopLayout } from '@plait/layouts';
+import { MindQueries } from '../queries';
+import { fromEvent } from 'rxjs';
+import { getChildrenCount } from '../utils/mind';
+import { filter, take } from 'rxjs/operators';
+import { getBranchColorByMindElement, getBranchWidthByMindElement } from '../utils/node-style/branch';
+import { getLayoutDirection, getPointByPlacement, moveXOfPoint, moveYOfPoint, transformPlacement } from '../utils/point-placement';
+import { HorizontalPlacement, VerticalPlacement } from '../interfaces/types';
+export class CollapseDrawer extends BaseDrawer {
+    canDraw(element) {
+        if (element.children.length && !PlaitMind.isMind(element)) {
+            return true;
+        }
+        return false;
+    }
+    baseDraw(element) {
+        const collapseG = createG();
+        this.g = collapseG;
+        collapseG.classList.add('collapse-container');
+        const node = MindElement.getNode(element);
+        const stroke = getBranchColorByMindElement(this.board, element);
+        const branchWidth = getBranchWidthByMindElement(this.board, element);
+        const layout = MindQueries.getLayoutByElement(element);
+        const isUnderlineShape = getShapeByElement(this.board, element) === MindElementShape.underline;
+        const isHorizontal = isHorizontalLayout(layout);
+        const nodeClient = getRectangleByNode(node);
+        let linkDirection = getLayoutDirection(node, isHorizontal);
+        if (isIndentedLayout(layout)) {
+            linkDirection = isTopLayout(layout) ? LayoutDirection.top : LayoutDirection.bottom;
+        }
+        let placement = [HorizontalPlacement.right, VerticalPlacement.middle];
+        transformPlacement(placement, linkDirection);
+        // underline shape and horizontal
+        if (isHorizontal && isUnderlineShape && !element.isRoot) {
+            placement[1] = VerticalPlacement.bottom;
+        }
+        let startPoint = getPointByPlacement(nodeClient, placement);
+        const endPoint = moveXOfPoint(startPoint, EXTEND_OFFSET, linkDirection);
+        const circleCenter = moveXOfPoint(endPoint, EXTEND_DIAMETER / 2, linkDirection);
+        const arrowPoints = this.getArrowPoints(circleCenter, linkDirection);
+        const arrowLine = drawLinearPath(arrowPoints, {
+            stroke,
+            strokeWidth: 2
+        });
+        const extendLine = PlaitBoard.getRoughSVG(this.board).line(startPoint[0], startPoint[1], endPoint[0], endPoint[1], {
+            strokeWidth: branchWidth,
+            stroke
+        });
+        const badge = PlaitBoard.getRoughSVG(this.board).circle(circleCenter[0], circleCenter[1], EXTEND_DIAMETER, {
+            fill: stroke,
+            stroke,
+            fillStyle: 'solid'
+        });
+        const hideCircleG = PlaitBoard.getRoughSVG(this.board).circle(circleCenter[0], circleCenter[1], EXTEND_DIAMETER, {
+            fill: '#fff',
+            stroke,
+            strokeWidth: branchWidth > 3 ? 3 : branchWidth,
+            fillStyle: 'solid'
+        });
+        if (element.isCollapsed) {
+            let numberOffset = 0;
+            if (getChildrenCount(element) >= 10)
+                numberOffset = -2;
+            if (getChildrenCount(element) === 1)
+                numberOffset = 1;
+            const badgeText = createText(circleCenter[0] - 4 + numberOffset, circleCenter[1] + 4, stroke, `${getChildrenCount(element)}`);
+            badge.setAttribute('style', 'opacity: 0.15');
+            badgeText.setAttribute('style', 'font-size: 12px');
+            collapseG.appendChild(badge);
+            collapseG.appendChild(badgeText);
+            collapseG.appendChild(extendLine);
+        }
+        else {
+            collapseG.appendChild(hideCircleG);
+            collapseG.appendChild(arrowLine);
+        }
+        collapseG.appendChild(extendLine);
+        return collapseG;
+    }
+    afterDraw(element) {
+        if (!this.g) {
+            throw new Error(`can not find quick insert g`);
+        }
+        fromEvent(this.g, 'mouseup')
+            .pipe(filter(() => !PlaitBoard.isPointer(this.board, PlaitPointerType.hand) || !!PlaitBoard.isReadonly(this.board)), take(1))
+            .subscribe(() => {
+            const isCollapsed = !element.isCollapsed;
+            const newElement = { isCollapsed };
+            const path = PlaitBoard.findPath(this.board, element);
+            Transforms.setNode(this.board, newElement, path);
+        });
+    }
+    getArrowPoints(circleCenter, linkDirection) {
+        let arrowTopPoint = moveXOfPoint(circleCenter, 2, linkDirection);
+        arrowTopPoint = moveYOfPoint(arrowTopPoint, 4, linkDirection);
+        const arrowMiddlePoint = moveXOfPoint(circleCenter, -2, linkDirection);
+        let arrowBottomPoint = moveXOfPoint(circleCenter, 2, linkDirection);
+        arrowBottomPoint = moveYOfPoint(arrowBottomPoint, -4, linkDirection);
+        return [arrowTopPoint, arrowMiddlePoint, arrowBottomPoint];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-collapse.drawer.js","sourceRoot":"","sources":["../../../../packages/mind/src/drawer/node-collapse.drawer.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, PlaitPointerType, Point, Transforms, createG, createText, drawLinearPath } from '@plait/core';\nimport { MindElement, BaseData, PlaitMind, MindElementShape, LayoutDirection } from '../interfaces';\nimport { AfterDraw, BaseDrawer } from '../base/base.drawer';\nimport { getRectangleByNode } from '../utils/position/node';\nimport { getShapeByElement } from '../utils/node-style/shape';\nimport { EXTEND_OFFSET, EXTEND_DIAMETER } from '../constants/default';\nimport { MindLayoutType, isHorizontalLayout, isIndentedLayout, isTopLayout } from '@plait/layouts';\nimport { MindQueries } from '../queries';\nimport { fromEvent } from 'rxjs';\nimport { getChildrenCount } from '../utils/mind';\nimport { filter, take } from 'rxjs/operators';\nimport { getBranchColorByMindElement, getBranchWidthByMindElement } from '../utils/node-style/branch';\nimport { getLayoutDirection, getPointByPlacement, moveXOfPoint, moveYOfPoint, transformPlacement } from '../utils/point-placement';\nimport { HorizontalPlacement, PointPlacement, VerticalPlacement } from '../interfaces/types';\n\nexport class CollapseDrawer extends BaseDrawer implements AfterDraw {\n    canDraw(element: MindElement<BaseData>): boolean {\n        if (element.children.length && !PlaitMind.isMind(element)) {\n            return true;\n        }\n        return false;\n    }\n\n    baseDraw(element: MindElement<BaseData>): SVGGElement {\n        const collapseG = createG();\n        this.g = collapseG;\n\n        collapseG.classList.add('collapse-container');\n\n        const node = MindElement.getNode(element);\n        const stroke = getBranchColorByMindElement(this.board, element);\n        const branchWidth = getBranchWidthByMindElement(this.board, element);\n        const layout = MindQueries.getLayoutByElement(element) as MindLayoutType;\n        const isUnderlineShape = getShapeByElement(this.board, element) === MindElementShape.underline;\n        const isHorizontal = isHorizontalLayout(layout);\n        const nodeClient = getRectangleByNode(node);\n        let linkDirection = getLayoutDirection(node, isHorizontal);\n        if (isIndentedLayout(layout)) {\n            linkDirection = isTopLayout(layout) ? LayoutDirection.top : LayoutDirection.bottom;\n        }\n\n        let placement: PointPlacement = [HorizontalPlacement.right, VerticalPlacement.middle];\n\n        transformPlacement(placement, linkDirection);\n\n        // underline shape and horizontal\n        if (isHorizontal && isUnderlineShape && !element.isRoot) {\n            placement[1] = VerticalPlacement.bottom;\n        }\n\n        let startPoint = getPointByPlacement(nodeClient, placement);\n        const endPoint = moveXOfPoint(startPoint, EXTEND_OFFSET, linkDirection);\n        const circleCenter = moveXOfPoint(endPoint, EXTEND_DIAMETER / 2, linkDirection);\n\n        const arrowPoints = this.getArrowPoints(circleCenter, linkDirection);\n\n        const arrowLine = drawLinearPath(arrowPoints, {\n            stroke,\n            strokeWidth: 2\n        });\n\n        const extendLine = PlaitBoard.getRoughSVG(this.board).line(startPoint[0], startPoint[1], endPoint[0], endPoint[1], {\n            strokeWidth: branchWidth,\n            stroke\n        });\n\n        const badge = PlaitBoard.getRoughSVG(this.board).circle(circleCenter[0], circleCenter[1], EXTEND_DIAMETER, {\n            fill: stroke,\n            stroke,\n            fillStyle: 'solid'\n        });\n\n        const hideCircleG = PlaitBoard.getRoughSVG(this.board).circle(circleCenter[0], circleCenter[1], EXTEND_DIAMETER, {\n            fill: '#fff',\n            stroke,\n            strokeWidth: branchWidth > 3 ? 3 : branchWidth,\n            fillStyle: 'solid'\n        });\n\n        if (element.isCollapsed) {\n            let numberOffset = 0;\n            if (getChildrenCount(element) >= 10) numberOffset = -2;\n            if (getChildrenCount(element) === 1) numberOffset = 1;\n\n            const badgeText = createText(circleCenter[0] - 4 + numberOffset, circleCenter[1] + 4, stroke, `${getChildrenCount(element)}`);\n            badge.setAttribute('style', 'opacity: 0.15');\n            badgeText.setAttribute('style', 'font-size: 12px');\n            collapseG.appendChild(badge);\n            collapseG.appendChild(badgeText);\n            collapseG.appendChild(extendLine);\n        } else {\n            collapseG.appendChild(hideCircleG);\n            collapseG.appendChild(arrowLine);\n        }\n\n        collapseG.appendChild(extendLine);\n        return collapseG;\n    }\n\n    afterDraw(element: MindElement): void {\n        if (!this.g) {\n            throw new Error(`can not find quick insert g`);\n        }\n\n        fromEvent(this.g, 'mouseup')\n            .pipe(\n                filter(() => !PlaitBoard.isPointer(this.board, PlaitPointerType.hand) || !!PlaitBoard.isReadonly(this.board)),\n                take(1)\n            )\n            .subscribe(() => {\n                const isCollapsed = !element.isCollapsed;\n                const newElement: Partial<MindElement> = { isCollapsed };\n                const path = PlaitBoard.findPath(this.board, element);\n                Transforms.setNode(this.board, newElement, path);\n            });\n    }\n\n    private getArrowPoints(circleCenter: Point, linkDirection: LayoutDirection) {\n        let arrowTopPoint = moveXOfPoint(circleCenter, 2, linkDirection);\n        arrowTopPoint = moveYOfPoint(arrowTopPoint, 4, linkDirection);\n        const arrowMiddlePoint = moveXOfPoint(circleCenter, -2, linkDirection);\n        let arrowBottomPoint = moveXOfPoint(circleCenter, 2, linkDirection);\n        arrowBottomPoint = moveYOfPoint(arrowBottomPoint, -4, linkDirection);\n\n        return [arrowTopPoint, arrowMiddlePoint, arrowBottomPoint];\n    }\n}\n"]}

package/esm2020/drawer/node-emojis.drawer.mjs

@@ -0,0 +1,72 @@
+import { MindElement } from '../interfaces';
+import { createForeignObject, createG } from '@plait/core';
+import { getEmojiFontSize } from '../utils/space/emoji';
+import { getEmojiForeignRectangle } from '../utils/position/emoji';
+class EmojiDrawer {
+    constructor(board, viewContainerRef) {
+        this.board = board;
+        this.viewContainerRef = viewContainerRef;
+        this.componentRef = null;
+    }
+    draw(emoji, element) {
+        this.destroy();
+        const componentType = this.board.drawEmoji(emoji, element);
+        this.componentRef = this.viewContainerRef.createComponent(componentType);
+        this.componentRef.instance.emojiItem = emoji;
+        this.componentRef.instance.board = this.board;
+        this.componentRef.instance.element = element;
+        this.componentRef.instance.fontSize = getEmojiFontSize(element);
+    }
+    get nativeElement() {
+        if (this.componentRef) {
+            return this.componentRef.instance.nativeElement;
+        }
+        else {
+            return null;
+        }
+    }
+    destroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+}
+export class NodeEmojisDrawer {
+    constructor(board, viewContainerRef) {
+        this.board = board;
+        this.viewContainerRef = viewContainerRef;
+        this.emojiDrawers = [];
+    }
+    drawEmojis(element) {
+        this.destroy();
+        if (MindElement.hasEmojis(element)) {
+            this.g = createG();
+            this.g.classList.add('emojis');
+            const foreignRectangle = getEmojiForeignRectangle(this.board, element);
+            const foreignObject = createForeignObject(foreignRectangle.x, foreignRectangle.y, foreignRectangle.width, foreignRectangle.height);
+            this.g.append(foreignObject);
+            const container = document.createElement('div');
+            container.classList.add('node-emojis-container');
+            foreignObject.append(container);
+            this.emojiDrawers = element.data.emojis.map(emojiItem => {
+                const drawer = new EmojiDrawer(this.board, this.viewContainerRef);
+                drawer.draw(emojiItem, element);
+                return drawer;
+            });
+            this.emojiDrawers.forEach(drawer => {
+                container.append(drawer.nativeElement);
+            });
+            return this.g;
+        }
+        return undefined;
+    }
+    destroy() {
+        if (this.g) {
+            this.g.remove();
+        }
+        this.emojiDrawers.forEach(drawer => drawer.destroy());
+        this.emojiDrawers = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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