@plait/mind 0.2.0-next.0

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@plait/mind" />
+export * from './public-api';

package/interfaces/abstract.d.ts

@@ -0,0 +1,4 @@
+export declare enum AbstractHandlePosition {
+    start = "start",
+    end = "end"
+}

package/interfaces/element-data.d.ts

@@ -0,0 +1,11 @@
+import { Element } from 'slate';
+export interface EmojiItem {
+    name: string;
+}
+export interface BaseData {
+    topic: Element;
+    emojis?: EmojiItem[];
+}
+export interface EmojiData extends BaseData {
+    emojis: EmojiItem[];
+}

package/interfaces/element.d.ts

@@ -0,0 +1,39 @@
+import { MindmapNodeShape } from '../constants/node';
+import { MindmapLayoutType } from '@plait/layouts';
+import { PlaitBoard, PlaitElement, Point } from '@plait/core';
+import { BaseData, EmojiData } from './element-data';
+export interface MindElement<T = BaseData> extends PlaitElement {
+    data: T;
+    children: MindElement[];
+    rightNodeCount?: number;
+    width: number;
+    height: number;
+    isRoot?: boolean;
+    fill?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    shape?: MindmapNodeShape;
+    linkLineColor?: string;
+    linkLineWidth?: number;
+    layout?: MindmapLayoutType;
+    isCollapsed?: boolean;
+    start?: number;
+    end?: number;
+}
+export interface PlaitMind extends MindElement {
+    type: 'mindmap';
+    points: Point[];
+}
+export declare const PlaitMind: {
+    isMind: (value: any) => value is PlaitMind;
+};
+export declare const MindElement: {
+    hasLayout(value: MindElement, layout: MindmapLayoutType): boolean;
+    isIndentedLayout(value: MindElement): boolean;
+    isMindElement(board: PlaitBoard, element: PlaitElement): element is MindElement<BaseData>;
+    getParent(node: MindElement): MindElement<BaseData>;
+    getRoot(board: PlaitBoard, element: MindElement): PlaitMind;
+    getNode(element: MindElement): import("@plait/mind").MindmapNode;
+    hasEmojis(element: MindElement): element is MindElement<EmojiData>;
+    getEmojis(element: MindElement<EmojiData>): import("./element-data").EmojiItem[];
+};

package/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+export * from './element';
+export * from './element-data';
+export * from './node';
+export * from './layout';
+export * from './abstract';

package/interfaces/layout.d.ts

@@ -0,0 +1,10 @@
+export declare enum LayoutDirection {
+    'top' = "top",
+    'right' = "right",
+    'bottom' = "bottom",
+    'left' = "left"
+}
+export declare const LayoutDirectionsMap: LayoutDirectionMapType;
+export type LayoutDirectionMapType = {
+    [key: string]: LayoutDirection[];
+};

package/interfaces/node.d.ts

@@ -0,0 +1,33 @@
+import { MindmapLayoutType } from '@plait/layouts';
+import { Path } from '@plait/core';
+import { MindElement } from './element';
+export interface MindmapNode {
+    depth: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hGap: number;
+    vGap: number;
+    children: MindmapNode[];
+    origin: MindElement;
+    parent: MindmapNode;
+    left: boolean;
+    up: boolean;
+}
+export declare const MindmapNode: {
+    get(root: MindmapNode, path: Path): MindmapNode;
+    isEquals(node: MindmapNode, otherNode: MindmapNode): boolean;
+};
+export type ExtendLayoutType = Exclude<MindmapLayoutType, MindmapLayoutType.standard>;
+export type CoordinateType = {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+};
+export type ExtendUnderlineCoordinateType = {
+    [key in ExtendLayoutType]: CoordinateType;
+};
+export type DetectResult = 'top' | 'bottom' | 'right' | 'left' | null;
+export type RootBaseDirection = 'right' | 'left' | null;

package/interfaces/types.d.ts

@@ -0,0 +1,11 @@
+export declare enum HorizontalPlacement {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+export declare enum VerticalPlacement {
+    top = "top",
+    middle = "middle",
+    bottom = "bottom"
+}
+export type PointPlacement = [HorizontalPlacement, VerticalPlacement];

package/layout-option.d.ts

@@ -0,0 +1,2 @@
+import { LayoutOptions } from "@plait/layouts";
+export declare const getLayoutOptions: () => LayoutOptions;

package/mind.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { PlaitMind } from './interfaces/element';
+import { MindmapNode } from './interfaces/node';
+import { BeforeContextChange, PlaitPluginElementContext } from '@plait/core';
+import { MindNodeComponent } from './node.component';
+import * as i0 from "@angular/core";
+export declare class PlaitMindComponent extends MindNodeComponent<PlaitMind> implements OnInit, BeforeContextChange<PlaitMind> {
+    root: MindmapNode;
+    rootG: SVGGElement;
+    ngOnInit(): void;
+    beforeContextChange(value: PlaitPluginElementContext<PlaitMind>): void;
+    updateMindmap(element?: PlaitMind): void;
+    updateMindmapLocation(element: PlaitMind): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaitMindComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlaitMindComponent, "plait-mind", never, {}, {}, never, never, false, never>;
+}

package/mind.module.d.ts

@@ -0,0 +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 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 ɵinj: i0.ɵɵInjectorDeclaration<MindModule>;
+}

package/node.component.d.ts

@@ -0,0 +1,60 @@
+import { ChangeDetectorRef, ComponentRef, OnDestroy, OnInit, Renderer2, ViewContainerRef } from '@angular/core';
+import { PlaitPluginElementComponent, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
+import { PlaitRichtextComponent } from '@plait/richtext';
+import { RoughSVG } from 'roughjs/bin/svg';
+import { Subject } from 'rxjs';
+import { MindElement } from './interfaces/element';
+import { MindmapNode } from './interfaces/node';
+import { EmojisDrawer } from './plugins/emoji/emoji.drawer';
+import { AbstractHandlePosition } from './interfaces';
+import * as i0 from "@angular/core";
+export declare class MindNodeComponent<T extends MindElement = MindElement> extends PlaitPluginElementComponent<T> implements OnInit, OnDestroy, OnContextChanged<T> {
+    private viewContainerRef;
+    protected cdr: ChangeDetectorRef;
+    private render2;
+    isEditable: boolean;
+    roughSVG: RoughSVG;
+    node: MindmapNode;
+    parent: MindmapNode;
+    index: number;
+    abstractIncludedOutlineG?: SVGGElement;
+    parentG: SVGGElement;
+    activeG: SVGGElement[];
+    shapeG: SVGGElement | null;
+    linkG?: SVGGElement;
+    richtextG?: SVGGElement;
+    foreignObject?: SVGForeignObjectElement;
+    extendG?: SVGGElement;
+    maskG: SVGGElement;
+    richtextComponentRef?: ComponentRef<PlaitRichtextComponent>;
+    destroy$: Subject<void>;
+    emojisDrawer: EmojisDrawer;
+    get handActive(): boolean;
+    constructor(viewContainerRef: ViewContainerRef, cdr: ChangeDetectorRef, render2: Renderer2);
+    ngOnInit(): void;
+    onContextChanged(value: PlaitPluginElementContext<T>, previous: PlaitPluginElementContext<T>): void;
+    drawShape(): void;
+    drawEmojis(): void;
+    destroyShape(): void;
+    drawLink(): void;
+    destroyLine(): void;
+    drawMaskG(): void;
+    destroyMaskG(): void;
+    enableMaskG(): void;
+    disabledMaskG(): void;
+    drawActiveG(): void;
+    destroyActiveG(): void;
+    updateActiveClass(): void;
+    drawRichtext(): void;
+    private drawQuickInsert;
+    drawExtend(): void;
+    destroyExtend(): void;
+    destroyRichtext(): void;
+    updateAbstractIncludedOutline(resizingLocation?: number, handlePosition?: AbstractHandlePosition): void;
+    updateRichtext(): void;
+    startEditText(isEnd: boolean, isClear: boolean): void;
+    trackBy: (index: number, node: MindmapNode) => string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MindNodeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MindNodeComponent<any>, "plait-mindmap-node", never, {}, {}, never, never, false, never>;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@plait/mind",
+  "version": "0.2.0-next.0",
+  "peerDependencies": {
+    "@angular/common": "^13.3.0",
+    "@angular/core": "^13.3.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2015/plait-mind.mjs",
+  "es2020": "fesm2020/plait-mind.mjs",
+  "esm2020": "esm2020/plait-mind.mjs",
+  "fesm2020": "fesm2020/plait-mind.mjs",
+  "fesm2015": "fesm2015/plait-mind.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2020": "./esm2020/plait-mind.mjs",
+      "es2020": "./fesm2020/plait-mind.mjs",
+      "es2015": "./fesm2015/plait-mind.mjs",
+      "node": "./fesm2015/plait-mind.mjs",
+      "default": "./fesm2020/plait-mind.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/plugins/emoji/emoji-base.component.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef } from '@angular/core';
+import { EmojiItem } from '../../interfaces/element-data';
+import * as i0 from "@angular/core";
+export declare class MindEmojiBaseComponent {
+    protected elementRef: ElementRef<HTMLElement>;
+    fontSize: number;
+    emojiItem: EmojiItem;
+    get nativeElement(): HTMLElement;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MindEmojiBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MindEmojiBaseComponent, never, never, { "fontSize": "fontSize"; "emojiItem": "emojiItem"; }, {}, never, never, false, never>;
+}

package/plugins/emoji/emoji.d.ts

@@ -0,0 +1,6 @@
+import { EmojiData, MindElement } from '../../interfaces';
+export declare function getEmojisRectangle(element: MindElement<EmojiData>): {
+    width: number;
+    height: number;
+};
+export declare function getEmojiFontSize(element: MindElement<EmojiData>): 14 | 18;

package/plugins/emoji/emoji.drawer.d.ts

@@ -0,0 +1,22 @@
+import { ComponentRef, ViewContainerRef } from '@angular/core';
+import { EmojiItem, MindElement } from '../../interfaces';
+import { MindEmojiBaseComponent } from './emoji-base.component';
+import { PlaitMindEmojiBoard } from './with-mind-emoji';
+export declare class EmojiDrawer {
+    private board;
+    private viewContainerRef;
+    componentRef: ComponentRef<MindEmojiBaseComponent> | null;
+    constructor(board: PlaitMindEmojiBoard, viewContainerRef: ViewContainerRef);
+    draw(emoji: EmojiItem, element: MindElement): void;
+    get nativeElement(): HTMLElement | null;
+    destroy(): void;
+}
+export declare class EmojisDrawer {
+    private board;
+    private viewContainerRef;
+    emojiDrawers: EmojiDrawer[];
+    g?: SVGGElement;
+    constructor(board: PlaitMindEmojiBoard, viewContainerRef: ViewContainerRef);
+    drawEmojis(element: MindElement): SVGGElement | undefined;
+    destroy(): void;
+}

package/plugins/emoji/index.d.ts

@@ -0,0 +1,3 @@
+export * from './with-mind-emoji';
+export * from './emoji';
+export * from './emoji-base.component';

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

@@ -0,0 +1,8 @@
+import { ComponentType, PlaitBoard } from '@plait/core';
+import { MindElement } from '../../interfaces/element';
+import { EmojiItem } from '../../interfaces/element-data';
+import { MindEmojiBaseComponent } from './emoji-base.component';
+export interface PlaitMindEmojiBoard extends PlaitBoard {
+    drawEmoji: (emoji: EmojiItem, element: MindElement) => ComponentType<MindEmojiBaseComponent>;
+}
+export declare const withEmoji: (board: PlaitBoard) => PlaitBoard & PlaitMindEmojiBoard;

package/plugins/with-abstract.d.ts

@@ -0,0 +1,2 @@
+import { PlaitPlugin } from '@plait/core';
+export declare const withAbstract: PlaitPlugin;

package/plugins/with-dnd.d.ts

@@ -0,0 +1,11 @@
+import { PlaitBoard } from '@plait/core';
+import { MindElement } from '../interfaces/element';
+import { DetectResult } from '../interfaces/node';
+import { MindNodeComponent } from '../node.component';
+export declare const withDnd: (board: PlaitBoard) => PlaitBoard;
+export declare const isValidTarget: (origin: MindElement, target: MindElement) => boolean;
+export declare const addActiveOnDragOrigin: (activeElement: MindElement, isOrigin?: boolean) => void;
+export declare const removeActiveOnDragOrigin: (activeElement: MindElement, isOrigin?: boolean) => void;
+export declare const updateRightNodeCount: (board: PlaitBoard, activeComponent: MindNodeComponent, targetComponent: MindNodeComponent, detectResult: DetectResult) => void;
+export declare const isDragging: (board: PlaitBoard) => boolean;
+export declare const setIsDragging: (board: PlaitBoard, state: boolean) => void;

package/plugins/with-mind.d.ts

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

package/public-api.d.ts

@@ -0,0 +1,10 @@
+export * from './mind.component';
+export * from './node.component';
+export * from './mind.module';
+export * from './utils';
+export * from './interfaces';
+export * from './plugins/with-mind';
+export * from './constants';
+export * from './queries/index';
+export * from './transforms/index';
+export * from './plugins/emoji';

package/queries/get-available-sublayouts-by-element.d.ts

@@ -0,0 +1,8 @@
+import { MindElement } from '../interfaces';
+import { MindmapLayoutType } from '@plait/layouts';
+/**
+ *  get available sub layouts by element
+ * @param element
+ * @returns MindmapLayoutType[]
+ */
+export declare const getAvailableSubLayoutsByElement: (element: MindElement) => MindmapLayoutType[] | undefined;

package/queries/get-branch-mindmap-layouts-by-element.d.ts

@@ -0,0 +1,3 @@
+import { MindElement } from '../interfaces';
+import { MindmapLayoutType } from '@plait/layouts';
+export declare const getBranchMindmapLayouts: (element: MindElement) => MindmapLayoutType[];

package/queries/get-correct-layout-by-element.d.ts

@@ -0,0 +1,9 @@
+import { MindElement } from '../interfaces';
+import { MindmapLayoutType } from '@plait/layouts';
+/**
+ * get correctly layout：
+ * 1. root is standard -> left or right
+ * 2. correct layout by incorrect layout direction
+ * @param element
+ */
+export declare const getCorrectLayoutByElement: (element: MindElement) => MindmapLayoutType;

package/queries/get-layout-by-element.d.ts

@@ -0,0 +1,3 @@
+import { MindElement } from '../interfaces';
+import { MindmapLayoutType } from '@plait/layouts';
+export declare const getLayoutByElement: (element: MindElement) => MindmapLayoutType;

package/queries/get-layout-parent-by-element.d.ts

@@ -0,0 +1,8 @@
+import { MindElement } from '../interfaces';
+import { MindmapLayoutType } from '@plait/layouts';
+/**
+ * 获取父节点布局类型
+ * @param element
+ * @returns MindmapLayoutType
+ */
+export declare const getLayoutParentByElement: (element: MindElement) => MindmapLayoutType;

package/queries/index.d.ts

@@ -0,0 +1,7 @@
+export declare const MindmapQueries: {
+    getAvailableSubLayoutsByElement: (element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>) => import("@plait/layouts").MindmapLayoutType[] | undefined;
+    getLayoutParentByElement: (element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>) => import("@plait/layouts").MindmapLayoutType;
+    getBranchMindmapLayouts: (element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>) => import("@plait/layouts").MindmapLayoutType[];
+    getLayoutByElement: (element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>) => import("@plait/layouts").MindmapLayoutType;
+    getCorrectLayoutByElement: (element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>) => import("@plait/layouts").MindmapLayoutType;
+};

package/styles/styles.scss

@@ -0,0 +1,99 @@
+$primary: #4e8afa;
+
+g[plait-mindmap='true'] {
+    .plait-richtext-container {
+        cursor: default;
+        min-width: 5px;
+        &[readonly='false'] {
+            cursor: text;
+            max-width: 34em;
+        }
+    }
+
+    .extend {
+        opacity: 0;
+        cursor: default;
+    }
+
+    .collapsed {
+        .extend {
+            opacity: 1;
+        }
+    }
+
+    .dragging-origin,
+    .dragging-child {
+        opacity: 0.6;
+    }
+
+    .node-emojis-container {
+        display: flex;
+        ::-moz-selection {
+            /* Code for Firefox */
+            background: none;
+        }
+        ::selection {
+            background: none;
+        }
+    }
+}
+.plait-board-container.focused:not(.selection-moving):not(.element-moving) {
+    .extend {
+        cursor: pointer;
+        &:hover {
+            opacity: 1;
+        }
+    }
+
+    g[plait-mindmap='true'] {
+        .hovered {
+            .extend {
+                opacity: 1;
+            }
+        }
+    }
+}
+
+.plait-board-container.hand {
+    svg {
+        cursor: grab;
+    }
+    .zoom-toolbar {
+        svg {
+            cursor: pointer;
+        }
+    }
+    .collapsed {
+        .extend:hover {
+            cursor: grab;
+        }
+    }
+    :not(.collapsed) > .extend {
+        display: none;
+    }
+}
+.plait-board-container.readonly {
+    .collapsed {
+        .extend:hover {
+            cursor: pointer;
+        }
+    }
+    :not(.collapsed) > .extend {
+        display: block;
+        .quick-insert {
+            display: none;
+        }
+    }
+}
+.plait-board-container.viewport-moving {
+    svg {
+        cursor: grabbing;
+    }
+}
+
+.fake-node {
+    .dragging {
+        cursor: pointer;
+        opacity: 0.6;
+    }
+}

package/transforms/index.d.ts

@@ -0,0 +1,7 @@
+export declare const MindTransforms: {
+    setLayout: (board: import("@plait/core").PlaitBoard, layout: import("@plait/layouts").MindmapLayoutType, path: import("@plait/core").Path) => void;
+    setTopic: (board: import("@plait/core").PlaitBoard, element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>, topic: import("slate").BaseElement, width: number, height: number) => void;
+    setTopicSize: (board: import("@plait/core").PlaitBoard, element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>, width: number, height: number) => void;
+    addEmoji: (board: import("@plait/core").PlaitBoard, element: import("@plait/mind").MindElement<import("@plait/mind").BaseData>, emojiItem: import("@plait/mind").EmojiItem) => void;
+    removeEmoji: (board: import("@plait/core").PlaitBoard, element: import("@plait/mind").MindElement<import("@plait/mind").EmojiData>, emojiItem: import("@plait/mind").EmojiItem) => void;
+};

package/transforms/layout.d.ts

@@ -0,0 +1,3 @@
+import { PlaitBoard, Path } from '@plait/core';
+import { MindmapLayoutType } from '@plait/layouts';
+export declare const setLayout: (board: PlaitBoard, layout: MindmapLayoutType, path: Path) => void;

package/transforms/node.d.ts

@@ -0,0 +1,8 @@
+import { Element } from 'slate';
+import { MindElement } from '../interfaces/element';
+import { PlaitBoard } from '@plait/core';
+import { EmojiData, EmojiItem } from '../interfaces/element-data';
+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;

package/utils/abstract/common.d.ts

@@ -0,0 +1,5 @@
+import { MindElement } from '../../interfaces/element';
+export declare const separateChildren: (parentElement: MindElement) => {
+    leftChildren: MindElement<import("@plait/mind").BaseData>[];
+    rightChildren: MindElement<import("@plait/mind").BaseData>[];
+};

package/utils/abstract/resize.d.ts

@@ -0,0 +1,21 @@
+import { PlaitBoard, Point, RectangleClient } from '@plait/core';
+import { AbstractHandlePosition, MindElement } from '../../interfaces';
+import { LayoutNode } from '@plait/layouts';
+export declare const getRectangleByResizingLocation: (abstractRectangle: RectangleClient, location: number, handlePosition: AbstractHandlePosition, isHorizontal: boolean) => {
+    y: number;
+    height: number;
+    x: number;
+    width: number;
+};
+export declare const getLocationScope: (board: PlaitBoard, handlePosition: AbstractHandlePosition, parentChildren: MindElement[], element: MindElement, parent: LayoutNode, isHorizontal: boolean) => {
+    max: number;
+    min: number;
+};
+export declare const getHitAbstractHandle: (board: PlaitBoard, element: MindElement, point: Point) => AbstractHandlePosition | null;
+export declare const getAbstractHandleRectangle: (rectangle: RectangleClient, isHorizontal: boolean, position: AbstractHandlePosition) => {
+    y: number;
+    height: number;
+    x: number;
+    width: number;
+};
+export declare function findLocationLeftIndex(board: PlaitBoard, parentChildren: MindElement[], location: number, isHorizontal: boolean): number;

package/utils/clipboard.d.ts

@@ -0,0 +1,7 @@
+import { PlaitBoard, PlaitElement, Point } from '@plait/core';
+import { MindElement } from '../interfaces';
+export declare const buildClipboardData: (board: PlaitBoard, selectedElements: MindElement[]) => MindElement<import("../interfaces").BaseData>[];
+export declare const setClipboardData: (data: DataTransfer | null, elements: MindElement[]) => void;
+export declare const getDataFromClipboard: (data: DataTransfer | null) => PlaitElement[];
+export declare const insertClipboardData: (board: PlaitBoard, elements: PlaitElement[], targetPoint: Point) => void;
+export declare const insertClipboardText: (board: PlaitBoard, parentElement: PlaitElement, text: string, width: number, height: number) => void;

package/utils/colors.d.ts

@@ -0,0 +1,4 @@
+import { MindElement } from '../interfaces';
+export declare const getStrokeByMindmapElement: (element: MindElement) => string;
+export declare const getLinkLineColorByMindmapElement: (element: MindElement) => string;
+export declare const getRootLinkLineColorByMindmapElement: (root: MindElement) => string;

package/utils/direction-corrector.d.ts

@@ -0,0 +1,3 @@
+import { DetectResult, MindmapNode } from '../interfaces';
+export declare const directionCorrector: (node: MindmapNode, detectResults: DetectResult[]) => DetectResult[] | null;
+export declare const getAllowedDirection: (detectResults: DetectResult[], illegalDirections: DetectResult[]) => DetectResult[] | null;

package/utils/direction-detector.d.ts

@@ -0,0 +1,9 @@
+import { Point } from '@plait/core';
+import { DetectResult, MindmapNode } from '../interfaces';
+/**
+ *
+ * @param targetNode
+ * @param centerPoint
+ * @returns DetectResult[] | null
+ */
+export declare const directionDetector: (targetNode: MindmapNode, centerPoint: Point) => DetectResult[] | null;

package/utils/draw-placeholder.d.ts

@@ -0,0 +1,42 @@
+import { RoughSVG } from 'roughjs/bin/svg';
+import { DetectResult, MindElement, MindmapNode } from '../interfaces';
+import { MindNodeComponent } from '../node.component';
+import { MindmapLayoutType } from '@plait/layouts';
+export declare const drawPlaceholderDropNodeG: (dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}, roughSVG: RoughSVG, fakeDropNodeG: SVGGElement | undefined) => void;
+export declare const drawCurvePlaceholderDropNodeG: (targetRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, detectResult: DetectResult, targetIndex: number, targetComponent: MindNodeComponent, roughSVG: RoughSVG, parentComponent: MindNodeComponent, fakeDropNodeG: SVGGElement | undefined) => void;
+export declare const drawStraightDropNodeG: (targetRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, detectResult: DetectResult, targetComponent: MindNodeComponent, roughSVG: RoughSVG, fakeDropNodeG: SVGGElement | undefined) => void;
+export declare const getHorizontalFakeY: (detectResult: 'top' | 'bottom', targetIndex: number, parentNode: MindmapNode, targetRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, layout: MindmapLayoutType, fakeY: number) => number;
+export declare const getIndentedFakePoint: (layout: MindmapLayoutType, pointOptions: {
+    fakeX: number;
+    fakeY: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    strokeWidth: number;
+}) => {
+    fakeX: number;
+    fakeY: number;
+};
+export declare const drawIndentNodeG: (fakeDropNodeG: SVGGElement, roughSVG: RoughSVG, fakePoint: {
+    fakeX: number;
+    fakeY: number;
+}, node: MindmapNode) => void;

package/utils/drop-target-corrector.d.ts

@@ -0,0 +1,8 @@
+import { DetectResult, MindElement } from '../interfaces';
+export declare const readjustmentDropTarget: (dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}) => {
+    target: MindElement;
+    detectResult: DetectResult;
+};

package/utils/graph.d.ts

@@ -0,0 +1,5 @@
+import { MindmapNode } from '../interfaces/node';
+import { PlaitBoard, Point, RectangleClient } from '@plait/core';
+import { MindElement } from '../interfaces';
+export declare function getRectangleByNode(node: MindmapNode): RectangleClient;
+export declare function hitMindmapElement(board: PlaitBoard, point: Point, element: MindElement): boolean;