@plait/mind 0.2.2 → 0.3.1

package/interfaces/index.d.ts

@@ -2,4 +2,4 @@ export * from './element';
 export * from './element-data';
 export * from './node';
 export * from './layout';
-export * from './abstract';
+export * from './pointer';

package/interfaces/pointer.d.ts

@@ -0,0 +1,3 @@
+export declare enum MindPointerType {
+    'mind' = "mind"
+}

package/mind.module.d.ts

@@ -1,11 +1,11 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./mind.component";
 import * as i2 from "./node.component";
-import * as i3 from "@angular/platform-browser";
+import * as i3 from "@angular/common";
 import * as i4 from "@plait/richtext";
 import * as i5 from "@plait/core";
 export declare class MindModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<MindModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MindModule, [typeof i1.PlaitMindComponent, typeof i2.MindNodeComponent], [typeof i3.BrowserModule, typeof i4.RichtextModule, typeof i5.PlaitModule], [typeof i1.PlaitMindComponent, typeof i2.MindNodeComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MindModule, [typeof i1.PlaitMindComponent, typeof i2.MindNodeComponent], [typeof i3.CommonModule, typeof i4.RichtextModule, typeof i5.PlaitModule], [typeof i1.PlaitMindComponent, typeof i2.MindNodeComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<MindModule>;
 }

package/node.component.d.ts

@@ -5,10 +5,10 @@ import { RoughSVG } from 'roughjs/bin/svg';
 import { Subject } from 'rxjs';
 import { MindElement } from './interfaces/element';
 import { MindNode } from './interfaces/node';
-import { EmojisDrawer } from './plugins/emoji/emoji.drawer';
-import { AbstractHandlePosition } from './interfaces';
+import { EmojisDrawer } from './drawer/emoji.drawer';
 import { QuickInsertDrawer } from './drawer/quick-insert.drawer';
-import { PlaitMindBoard } from './plugins/with-extend-mind';
+import { PlaitMindBoard } from './plugins/with-mind.board';
+import { AbstractHandlePosition } from './plugins/with-abstract-resize.board';
 import * as i0 from "@angular/core";
 export declare class MindNodeComponent extends PlaitPluginElementComponent<MindElement, PlaitMindBoard> implements OnInit, OnDestroy, OnContextChanged<MindElement, PlaitMindBoard> {
     private viewContainerRef;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@plait/mind",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "peerDependencies": {
-    "@angular/common": "^13.3.0",
-    "@angular/core": "^13.3.0"
+    "@angular/common": "^15.2.2",
+    "@angular/core": "^15.2.2"
   },
   "dependencies": {
     "tslib": "^2.3.0"

package/{interfaces/abstract.d.ts → plugins/with-abstract-resize.board.d.ts}

@@ -1,5 +1,5 @@
 import { PlaitBoard } from '@plait/core';
-import { MindElement } from './element';
+import { MindElement } from '../interfaces/element';
 import { AbstractNode } from '@plait/layouts';
 export declare enum AbstractHandlePosition {
     start = "start",
@@ -11,6 +11,6 @@ export declare enum AbstractResizeState {
     end = "end"
 }
 export interface PlaitAbstractBoard extends PlaitBoard {
-    abstractResize?: (state: AbstractResizeState) => void;
+    onAbstractResize?: (state: AbstractResizeState) => void;
 }
 export type AbstractRefs = Map<MindElement, Pick<AbstractNode, 'start' | 'end'>>;

package/plugins/with-mind-create.d.ts

@@ -0,0 +1,11 @@
+import { PlaitBoard } from '@plait/core';
+import { PlaitMindBoard } from './with-mind.board';
+import { ComponentRef } from '@angular/core';
+import { PlaitRichtextComponent } from '@plait/richtext';
+export interface FakeCreateNodeRef {
+    nodeG: SVGGElement;
+    instanceRef: ComponentRef<PlaitRichtextComponent>;
+    foreignObject: SVGForeignObjectElement;
+    topicG: SVGGElement;
+}
+export declare const withCreateMind: (board: PlaitBoard) => PlaitBoard & PlaitMindBoard;

package/plugins/with-mind-extend.d.ts

@@ -0,0 +1,3 @@
+import { PlaitBoard } from '@plait/core';
+import { PlaitMindBoard } from './with-mind.board';
+export declare const withMindExtend: (board: PlaitBoard) => PlaitBoard & PlaitMindBoard;

package/plugins/{with-extend-mind.d.ts → with-mind.board.d.ts}

@@ -1,10 +1,10 @@
-import { ComponentType, PlaitBoard } from '@plait/core';
+import { ComponentType } from '@plait/core';
 import { MindElement } from '../interfaces/element';
 import { EmojiItem } from '../interfaces/element-data';
-import { MindEmojiBaseComponent } from './emoji';
 import { MindOptions } from '../interfaces/options';
-export interface PlaitMindBoard extends PlaitBoard {
+import { PlaitAbstractBoard } from './with-abstract-resize.board';
+import { MindEmojiBaseComponent } from '../base/emoji-base.component';
+export interface PlaitMindBoard extends PlaitAbstractBoard {
     drawEmoji: (emoji: EmojiItem, element: MindElement) => ComponentType<MindEmojiBaseComponent>;
     getMindOptions: () => MindOptions;
 }
-export declare const withExtendMind: (board: PlaitBoard) => PlaitBoard & PlaitMindBoard;

package/plugins/with-mind.d.ts

@@ -1,2 +1,2 @@
 import { PlaitBoard } from '@plait/core';
-export declare const withMind: (board: PlaitBoard) => PlaitBoard & import("./with-extend-mind").PlaitMindBoard;
+export declare const withMind: (board: PlaitBoard) => PlaitBoard & import("@plait/mind").PlaitMindBoard;

package/public-api.d.ts

@@ -4,8 +4,10 @@ export * from './mind.module';
 export * from './utils';
 export * from './interfaces';
 export * from './plugins/with-mind';
-export * from './plugins/with-extend-mind';
+export * from './plugins/with-mind-extend';
 export * from './constants';
 export * from './queries/index';
 export * from './transforms/index';
-export * from './plugins/emoji';
+export * from './base';
+export * from './plugins/with-mind.board';
+export * from './plugins/with-abstract-resize.board';

package/styles/styles.scss

@@ -28,7 +28,7 @@ g[plait-mindmap='true'] {
 }
 
 .plait-board-container {
-    &.focused:not(.selection-moving):not(.element-moving):not(.abstract-resizing-horizontal):not(.abstract-resizing-vertical) {
+    &.focused:not(.selection-moving):not(.element-moving):not(.abstract-resizing-horizontal):not(.abstract-resizing-vertical):not(.pointer-mind) {
         .extend {
             cursor: pointer;
             &:hover {
@@ -45,7 +45,7 @@ g[plait-mindmap='true'] {
         }
     }
 
-    &.hand {
+    &.pointer-hand {
         svg {
             cursor: grab;
         }
@@ -110,6 +110,9 @@ g[plait-mindmap='true'] {
         &.dragging {
             cursor: pointer;
             opacity: 0.6;
+            .plait-richtext-container {
+                opacity: 0.6;
+            }
         }
     }
 }

package/transforms/abstract-node.d.ts

@@ -1,5 +1,5 @@
 import { PlaitBoard, PlaitElement } from '@plait/core';
-import { AbstractRefs } from '../interfaces/abstract';
+import { AbstractRefs } from '../plugins/with-abstract-resize.board';
 import { MindElement } from '../interfaces/element';
 export declare const setAbstractsByRefs: (board: PlaitBoard, abstractRefs: AbstractRefs) => void;
 export declare const setAbstractByStandardLayout: (board: PlaitBoard, element: MindElement) => void;

package/transforms/emoji.d.ts

@@ -0,0 +1,6 @@
+import { MindElement } from '../interfaces/element';
+import { PlaitBoard } from '@plait/core';
+import { EmojiData, EmojiItem } from '../interfaces/element-data';
+export declare const addEmoji: (board: PlaitBoard, element: MindElement, emojiItem: EmojiItem) => void;
+export declare const removeEmoji: (board: PlaitBoard, element: MindElement<EmojiData>, emojiItem: EmojiItem) => void;
+export declare const replaceEmoji: (board: PlaitBoard, element: MindElement<EmojiData>, oldEmoji: EmojiItem, newEmoji: EmojiItem) => void;

package/transforms/index.d.ts

@@ -8,4 +8,7 @@ export declare const MindTransforms: {
     insertAbstract: (board: import("@plait/core").PlaitBoard, elements: import("@plait/core").PlaitElement[]) => void;
     setAbstractsByRefs: (board: import("@plait/core").PlaitBoard, abstractRefs: import("@plait/mind").AbstractRefs) => void;
     setAbstractByStandardLayout: (board: import("@plait/core").PlaitBoard, element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>) => void;
+    removeElements: (board: import("@plait/core").PlaitBoard, elements: import("@plait/mind").MindElement<import("@plait/mind").BaseData>[]) => void;
+    insertNodes: (board: import("@plait/core").PlaitBoard, elements: import("@plait/mind").MindElement<import("@plait/mind").BaseData>[], path: import("slate").Path) => void;
+    insertAbstractNodes: (board: import("@plait/core").PlaitBoard, validAbstractRefs: import("@plait/mind").AbstractRef[], elements: import("@plait/mind").MindElement<import("@plait/mind").BaseData>[], path: import("slate").Path) => void;
 };

package/transforms/node.d.ts

@@ -1,9 +1,9 @@
-import { Element } from 'slate';
+import { Element, Path } from 'slate';
 import { MindElement } from '../interfaces/element';
 import { PlaitBoard } from '@plait/core';
-import { EmojiData, EmojiItem } from '../interfaces/element-data';
+import { AbstractRef } from '../utils/abstract/common';
 export declare const setTopic: (board: PlaitBoard, element: MindElement, topic: Element, width: number, height: number) => void;
 export declare const setTopicSize: (board: PlaitBoard, element: MindElement, width: number, height: number) => void;
-export declare const addEmoji: (board: PlaitBoard, element: MindElement, emojiItem: EmojiItem) => void;
-export declare const removeEmoji: (board: PlaitBoard, element: MindElement<EmojiData>, emojiItem: EmojiItem) => void;
-export declare const replaceEmoji: (board: PlaitBoard, element: MindElement<EmojiData>, oldEmoji: EmojiItem, newEmoji: EmojiItem) => void;
+export declare const removeElements: (board: PlaitBoard, elements: MindElement[]) => void;
+export declare const insertNodes: (board: PlaitBoard, elements: MindElement[], path: Path) => void;
+export declare const insertAbstractNodes: (board: PlaitBoard, validAbstractRefs: AbstractRef[], elements: MindElement[], path: Path) => void;

package/utils/abstract/common.d.ts

@@ -7,8 +7,23 @@ export declare const separateChildren: (parentElement: MindElement) => {
 };
 export declare const isSetAbstract: (element: PlaitElement) => boolean;
 export declare const canSetAbstract: (element: PlaitElement) => boolean;
-export declare const getCorrespondingAbstract: (parent: MindElement, element: MindElement) => MindElement<import("@plait/mind").BaseData> | undefined;
-export declare const getBehindAbstracts: (parent: MindElement, element: MindElement) => MindElement<import("@plait/mind").BaseData>[];
+export declare const getCorrespondingAbstract: (element: MindElement) => MindElement<import("@plait/mind").BaseData> | undefined;
+export declare const getBehindAbstracts: (element: MindElement) => MindElement<import("@plait/mind").BaseData>[];
+/**
+ * return corresponding abstract that is not child of elements
+ */
 export declare const getOverallAbstracts: (board: PlaitBoard, elements: MindElement[]) => (MindElement<import("@plait/mind").BaseData> & AbstractNode)[];
-export declare const insertElementHandleAbstract: (board: PlaitBoard, path: Path, isExtendPreviousNode?: boolean, abstractRefs?: Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>) => Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>;
-export declare const deleteElementHandleAbstract: (board: PlaitBoard, deletableElements: MindElement[], abstractRefs?: Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>) => Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>;
+export interface AbstractRef {
+    abstract: MindElement & AbstractNode;
+    references: MindElement[];
+}
+/**
+ * abstract node is valid when elements contains at least one element it is referenced with
+ */
+export declare const getValidAbstractRefs: (board: PlaitBoard, elements: MindElement[]) => AbstractRef[];
+export declare function getRelativeStartEndByAbstractRef(abstractRef: AbstractRef, elements: MindElement[]): {
+    start: number;
+    end: number;
+};
+export declare const insertElementHandleAbstract: (board: PlaitBoard, path: Path, step?: number, isExtendPreviousNode?: boolean, effectedAbstracts?: Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>) => Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>;
+export declare const deleteElementHandleAbstract: (board: PlaitBoard, deletableElements: MindElement[], effectedAbstracts?: Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>) => Map<MindElement<import("@plait/mind").BaseData>, Pick<AbstractNode, "end" | "start">>;

package/utils/abstract/resize.d.ts

@@ -1,6 +1,7 @@
 import { PlaitBoard, PlaitElement, Point, RectangleClient } from '@plait/core';
-import { AbstractHandlePosition, MindElement } from '../../interfaces';
+import { MindElement } from '../../interfaces';
 import { LayoutNode } from '@plait/layouts';
+import { AbstractHandlePosition } from '../../plugins/with-abstract-resize.board';
 export declare const getRectangleByResizingLocation: (abstractRectangle: RectangleClient, location: number, activeHandlePosition: AbstractHandlePosition, isHorizontal: boolean) => {
     y: number;
     height: number;

package/utils/dnd/common.d.ts

@@ -0,0 +1,7 @@
+import { MindElement } from '../../interfaces/element';
+import { PlaitBoard } from '@plait/core';
+export declare const IS_DRAGGING: WeakMap<PlaitBoard, boolean>;
+export declare const addActiveOnDragOrigin: (activeElement: MindElement, isOrigin?: boolean) => void;
+export declare const removeActiveOnDragOrigin: (activeElement: MindElement, isOrigin?: boolean) => void;
+export declare const isDragging: (board: PlaitBoard) => boolean;
+export declare const setIsDragging: (board: PlaitBoard, state: boolean) => void;

package/utils/dnd/detector.d.ts

@@ -0,0 +1,31 @@
+import { MindElement } from '../../interfaces/element';
+import { PlaitBoard, Point, Path } from '@plait/core';
+import { DetectResult, MindNode } from '../../interfaces/node';
+/**
+ *
+ * @param targetNode
+ * @param centerPoint
+ * @returns DetectResult[] | null
+ */
+export declare const directionCorrector: (board: PlaitBoard, node: MindNode, detectResults: DetectResult[]) => DetectResult[] | null;
+export declare const getAllowedDirection: (detectResults: DetectResult[], illegalDirections: DetectResult[]) => DetectResult[] | null;
+export declare const detectDropTarget: (board: PlaitBoard, detectPoint: Point, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+} | null, activeElements: MindElement[]) => {
+    target: MindElement;
+    detectResult: DetectResult;
+} | null;
+export declare const directionDetector: (targetNode: MindNode, centerPoint: Point) => DetectResult[] | null;
+export declare const readjustmentDropTarget: (board: PlaitBoard, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}) => {
+    target: MindElement;
+    detectResult: DetectResult;
+};
+export declare const isValidTarget: (origin: MindElement, target: MindElement) => boolean;
+export declare const getPathByDropTarget: (board: PlaitBoard, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}) => Path;

package/utils/dnd/draw.d.ts

@@ -0,0 +1,9 @@
+import { MindElement } from '../../interfaces';
+import { MindNodeComponent } from '../../node.component';
+import { PlaitBoard, Path } from '@plait/core';
+export declare const drawFakeDragNode: (board: PlaitBoard, activeComponent: MindNodeComponent, offsetX: number, offsetY: number) => SVGGElement;
+export declare const drawFakeDropNodeByPath: (board: PlaitBoard, target: MindElement, path: Path) => SVGGElement;
+export declare const getPreviousAndNextByPath: (parent: MindElement, target: MindElement, path: Path) => {
+    hasPreviousNode: boolean;
+    hasNextNode: boolean;
+};

package/utils/index.d.ts

@@ -1,12 +1,12 @@
-export * from './graph';
+export * from './position';
 export * from './weak-maps';
 export * from './mind';
 export * from './layout';
+export * from './node';
 export * from './node-style';
 export * from './is-virtual-key';
-export * from './draw-placeholder';
-export * from './direction-detector';
-export * from './direction-corrector';
-export * from './drop-target-corrector';
+export * from './dnd/common';
+export * from './dnd/detector';
+export * from './dnd/draw';
 export * from './abstract/common';
 export * from './abstract/resize';

package/utils/mind.d.ts

@@ -1,36 +1,17 @@
-import { MindLayoutType } from '@plait/layouts';
-import { Path, PlaitBoard, Point } from '@plait/core';
-import { MindElementShape, MindNode } from '../interfaces';
+import { Path, PlaitBoard } from '@plait/core';
+import { MindNode } from '../interfaces';
 import { MindElement } from '../interfaces/element';
-export declare function findUpElement(element: MindElement): {
-    root: MindElement;
-    branch?: MindElement;
-};
 export declare const getChildrenCount: (element: MindElement) => number;
 export declare const isChildElement: (origin: MindElement, child: MindElement) => boolean;
 export declare const getFirstLevelElement: (elements: MindElement[]) => MindElement<import("../interfaces").BaseData>[];
 export declare const isChildRight: (node: MindNode, child: MindNode) => boolean;
 export declare const isChildUp: (node: MindNode, child: MindNode) => boolean;
 export declare const copyNewNode: (node: MindElement) => MindElement<import("../interfaces").BaseData>;
-export declare const transformRootToNode: (board: PlaitBoard, node: MindElement) => MindElement<import("../interfaces").BaseData>;
-export declare const transformAbstractToNode: (node: MindElement) => MindElement<import("../interfaces").BaseData>;
-export declare const transformNodeToRoot: (board: PlaitBoard, node: MindElement) => MindElement;
 export declare const extractNodesText: (node: MindElement) => string;
 export declare const changeRightNodeCount: (board: PlaitBoard, parentPath: Path, changeNumber: number) => void;
-export declare const shouldChangeRightNodeCount: (selectedElement: MindElement) => boolean;
-export declare const createDefaultMindMapElement: (point: Point, rightNodeCount: number, layout: MindLayoutType) => MindElement<import("../interfaces").BaseData>;
-export declare const createMindElement: (text: string, width: number, height: number, options: {
-    fill?: string;
-    strokeColor?: string;
-    strokeWidth?: number;
-    shape?: MindElementShape;
-    layout?: MindLayoutType;
-    branchColor?: string;
-    branchWidth?: number;
-}) => MindElement<import("../interfaces").BaseData>;
+export declare const isInRightBranchOfStandardLayout: (selectedElement: MindElement) => boolean;
 export declare const insertMindElement: (board: PlaitBoard, inheritNode: MindElement, path: Path) => void;
 export declare const findLastChild: (child: MindNode) => MindNode;
-export declare const deleteSelectedELements: (board: PlaitBoard, selectedElements: MindElement[]) => void;
 export declare const divideElementByParent: (elements: MindElement[]) => {
     parentElements: MindElement<import("../interfaces").BaseData>[];
     abstractIncludedGroups: MindElement<import("../interfaces").BaseData>[][];

package/utils/node/adjust-node.d.ts

@@ -0,0 +1,5 @@
+import { PlaitBoard } from '@plait/core';
+import { MindElement } from '../../interfaces/element';
+export declare const adjustRootToNode: (board: PlaitBoard, node: MindElement) => MindElement<import("@plait/mind").BaseData>;
+export declare const adjustAbstractToNode: (node: MindElement) => MindElement<import("@plait/mind").BaseData>;
+export declare const adjustNodeToRoot: (board: PlaitBoard, node: MindElement) => MindElement;

package/utils/{node.d.ts → node/common.d.ts}

@@ -1,2 +1,2 @@
-import { MindElement } from '../interfaces/element';
+import { MindElement } from '../../interfaces/element';
 export declare function enterNodeEditing(element: MindElement): void;

package/utils/node/create-node.d.ts

@@ -0,0 +1,14 @@
+import { PlaitBoard, Point } from '@plait/core';
+import { MindLayoutType } from '@plait/layouts';
+import { MindElement, MindElementShape } from '../../interfaces/element';
+export declare const createEmptyMind: (board: PlaitBoard, point: Point) => MindElement<import("@plait/mind").BaseData>;
+export declare const createDefaultMind: (point: Point, rightNodeCount: number, layout: MindLayoutType) => MindElement<import("@plait/mind").BaseData>;
+export declare const createMindElement: (text: string, width: number, height: number, options: {
+    fill?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    shape?: MindElementShape;
+    layout?: MindLayoutType;
+    branchColor?: string;
+    branchWidth?: number;
+}) => MindElement<import("@plait/mind").BaseData>;

package/utils/node/index.d.ts

@@ -0,0 +1,3 @@
+export * from './adjust-node';
+export * from './create-node';
+export * from './common';

package/utils/point-placement.d.ts

@@ -3,6 +3,13 @@ import { MindNode } from '../interfaces/node';
 import { LayoutDirection } from '../interfaces/layout';
 import { PointPlacement } from '../interfaces/types';
 export declare const getPointByPlacement: (client: RectangleClient, placement: PointPlacement) => Point;
+export interface PlacementRef {
+    placement: PointPlacement;
+    client: RectangleClient;
+}
+export declare const getXDistanceBetweenPoint: (point1: Point, point2: Point, isHorizontalLayout: boolean) => number;
+export declare const getYDistanceBetweenPoint: (point1: Point, point2: Point, isHorizontalLayout: boolean) => void;
 export declare const getLayoutDirection: (node: MindNode, isHorizontal: boolean) => LayoutDirection;
-export declare const movePoint: (point: Point, distance: number, direction?: LayoutDirection) => Point;
+export declare const moveXOfPoint: (point: Point, distance: number, direction?: LayoutDirection) => Point;
+export declare const moveYOfPoint: (point: Point, distance: number, direction?: LayoutDirection) => Point;
 export declare const transformPlacement: (placement: PointPlacement, direction: LayoutDirection) => void;

package/utils/position/emoji.d.ts

@@ -0,0 +1,7 @@
+import { PlaitBoard, Point, RectangleClient } from "@plait/core";
+import { MindElement } from "../../interfaces/element";
+import { EmojiData } from "../../interfaces/element-data";
+import { PlaitMindBoard } from "../../plugins/with-mind.board";
+export declare function getEmojiRectangle(board: PlaitMindBoard, element: MindElement<EmojiData>): RectangleClient;
+export declare function getEmojiForeignRectangle(board: PlaitMindBoard, element: MindElement<EmojiData>): RectangleClient;
+export declare const isHitEmojis: (board: PlaitBoard, element: MindElement<EmojiData>, point: Point) => boolean;

package/utils/position/index.d.ts

@@ -0,0 +1,3 @@
+export * from './node';
+export * from './emoji';
+export * from './topic';

package/utils/position/node.d.ts

@@ -0,0 +1,12 @@
+import { PlaitBoard, Point, RectangleClient } from '@plait/core';
+import { MindNode } from '../../interfaces/node';
+import { MindElement } from '../../interfaces/element';
+import { PlaitMindBoard } from '../../plugins/with-mind.board';
+export declare function getRectangleByNode(node: MindNode): RectangleClient;
+export declare function getRectangleByElement(board: PlaitMindBoard, originPoint: Point, element: MindElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function isHitMindElement(board: PlaitBoard, point: Point, element: MindElement): boolean;

package/utils/position/topic.d.ts

@@ -0,0 +1,16 @@
+import { MindElement } from '../../interfaces/element';
+import { MindNode } from '../../interfaces/node';
+import { PlaitMindBoard } from '../../plugins/with-mind.board';
+import { RectangleClient } from '@plait/core';
+export declare function getTopicRectangleByNode(board: PlaitMindBoard, node: MindNode): {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};
+export declare function getTopicRectangleByElement(board: PlaitMindBoard, nodeRectangle: RectangleClient, element: MindElement): {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};

package/utils/space/emoji.d.ts

@@ -0,0 +1,7 @@
+import { EmojiData, MindElement } from '../../interfaces';
+import { PlaitMindBoard } from '../../plugins/with-mind.board';
+export declare function getEmojisWidthHeight(board: PlaitMindBoard, element: MindElement<EmojiData>): {
+    width: number;
+    height: number;
+};
+export declare function getEmojiFontSize(element: MindElement<EmojiData>): number;

package/{layout-option.d.ts → utils/space/layout-options.d.ts}

@@ -1,3 +1,3 @@
 import { LayoutOptions } from "@plait/layouts";
-import { PlaitMindBoard } from "./plugins/with-extend-mind";
+import { PlaitMindBoard } from "../../plugins/with-mind.board";
 export declare const getLayoutOptions: (board: PlaitMindBoard) => LayoutOptions;

package/utils/{node-space.d.ts → space/node-space.d.ts}

@@ -1,9 +1,9 @@
-import { MindElement } from '../interfaces/element';
-import { PlaitMindBoard } from '../plugins/with-extend-mind';
-import { EmojiData } from '../interfaces/element-data';
+import { MindElement } from '../../interfaces/element';
+import { EmojiData } from '../../interfaces/element-data';
+import { PlaitMindBoard } from '../../plugins/with-mind.board';
 export declare const NodeSpace: {
     getNodeWidth(board: PlaitMindBoard, element: MindElement): number;
-    getNodeHeight(element: MindElement): number;
+    getNodeHeight(board: PlaitMindBoard, element: MindElement): number;
     getTextLeftSpace(board: PlaitMindBoard, element: MindElement): number;
     getTextTopSpace(element: MindElement): number;
     getEmojiLeftSpace(board: PlaitMindBoard, element: MindElement<EmojiData>): number;

package/draw/link.d.ts

@@ -1,3 +0,0 @@
-import { MindNode } from '../interfaces/node';
-import { PlaitBoard } from '@plait/core';
-export declare function drawLink(board: PlaitBoard, node: MindNode, child: MindNode, defaultStroke?: string | null, isHorizontal?: boolean, needDrawUnderline?: boolean): SVGGElement;

package/draw/richtext.d.ts

@@ -1,15 +0,0 @@
-import { ViewContainerRef } from '@angular/core';
-import { MindNode } from '../interfaces/node';
-import { PlaitMindBoard } from '../plugins/with-extend-mind';
-export declare function drawMindNodeRichtext(board: PlaitMindBoard, node: MindNode, viewContainerRef: ViewContainerRef): {
-    richtextComponentRef: import("@angular/core").ComponentRef<import("@plait/richtext").PlaitRichtextComponent>;
-    richtextG: SVGGElement;
-    foreignObject: SVGForeignObjectElement;
-};
-export declare function updateMindNodeTopicSize(board: PlaitMindBoard, node: MindNode, g: SVGGElement, isEditable: boolean): void;
-export declare function getRichtextRectangleByNode(board: PlaitMindBoard, node: MindNode): {
-    height: number;
-    width: number;
-    x: number;
-    y: number;
-};

package/draw/shape.d.ts

@@ -1,3 +0,0 @@
-import { MindNode } from '../interfaces/node';
-import { PlaitBoard } from '@plait/core';
-export declare function drawRectangleNode(board: PlaitBoard, node: MindNode): SVGGElement;