@plait/mind 0.91.0 → 0.92.0-next.0

package/index.d.ts

@@ -1,5 +1,603 @@
+import * as _plait_mind from '@plait/mind';
+import * as _plait_layouts from '@plait/layouts';
+import { MindLayoutType, AbstractNode, LayoutNode, LayoutOptions } from '@plait/layouts';
+import * as _plait_core from '@plait/core';
+import { PlaitElement, PlaitBoard, Point, Path, ThemeColor, ThemeColorMode, WithPluginOptions, PlaitOptionsBoard, OnContextChanged, PlaitPluginElementContext, BeforeContextChange, RectangleClient } from '@plait/core';
+import * as _plait_common from '@plait/common';
+import { ParagraphElement, CommonImageItem, StrokeStyle, RenderComponentRef, Generator, CommonElementFlavour, ImageGenerator, TextManage } from '@plait/common';
+import { RoughSVG } from 'roughjs/bin/svg';
+import * as slate from 'slate';
+import { Element as Element$1, Path as Path$1 } from 'slate';
+
+interface EmojiItem {
+    name: string;
+}
+interface BaseData {
+    topic: ParagraphElement;
+    emojis?: EmojiItem[];
+    image?: CommonImageItem;
+}
+interface EmojiData extends BaseData {
+    emojis: EmojiItem[];
+}
+interface ImageData extends BaseData {
+    image: CommonImageItem;
+}
+
+interface BaseMindElement extends PlaitElement {
+    rightNodeCount?: number;
+    manualWidth?: number;
+    fill?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: StrokeStyle;
+    shape?: MindElementShape;
+    branchColor?: string;
+    branchWidth?: number;
+    branchShape?: BranchShape;
+    layout?: MindLayoutType;
+    isCollapsed?: boolean;
+    start?: number;
+    end?: number;
+}
+interface PlaitMind<T = BaseData> extends MindElement<T> {
+    type: 'mind' | 'mindmap';
+    points: Point[];
+}
+declare const PlaitMind: {
+    isMind: (value: any) => value is PlaitMind;
+};
+interface MindElement<T = BaseData> extends BaseMindElement {
+    type: 'mind_child' | 'mind' | 'mindmap';
+    children: MindElement[];
+    data: T;
+}
+declare const MindElement: {
+    isIndentedLayout(board: PlaitBoard, value: MindElement): boolean;
+    isMindElement(board: PlaitBoard | null, element: PlaitElement): element is MindElement;
+    getParent(node: MindElement): MindElement<BaseData>;
+    findParent(node: MindElement): MindElement<BaseData> | undefined;
+    getRoot(board: PlaitBoard, element: MindElement): PlaitMind;
+    getAncestors(board: PlaitBoard, element: MindElement): PlaitElement[];
+    getNode(element: MindElement): _plait_mind.MindNode;
+    findParentNode(element: MindElement): _plait_mind.MindNode | undefined;
+    hasEmojis(element: MindElement): element is MindElement<EmojiData>;
+    hasImage(element: MindElement): element is MindElement<ImageData>;
+    getEmojis(element: MindElement<EmojiData>): _plait_mind.EmojiItem[];
+};
+declare enum MindElementShape {
+    roundRectangle = "round-rectangle",
+    underline = "underline"
+}
+declare enum BranchShape {
+    bight = "bight",
+    polyline = "polyline"
+}
+
+interface MindNode {
+    depth: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hGap: number;
+    vGap: number;
+    children: MindNode[];
+    origin: MindElement;
+    parent: MindNode;
+    left: boolean;
+    up: boolean;
+}
+declare const MindNode: {
+    get(root: MindNode, path: Path): MindNode;
+};
+type ExtendLayoutType = Exclude<MindLayoutType, MindLayoutType.standard>;
+type CoordinateType = {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+};
+type ExtendUnderlineCoordinateType = {
+    [key in ExtendLayoutType]: CoordinateType;
+};
+type DetectResult = 'top' | 'bottom' | 'right' | 'left' | null;
+type RootBaseDirection = 'right' | 'left' | null;
+
+declare enum LayoutDirection {
+    'top' = "top",
+    'right' = "right",
+    'bottom' = "bottom",
+    'left' = "left"
+}
+declare const LayoutDirectionsMap: LayoutDirectionMapType;
+type LayoutDirectionMapType = {
+    [key: string]: LayoutDirection[];
+};
+
+declare enum MindPointerType {
+    'mind' = "mind"
+}
+
+declare const MindDefaultThemeColor: MindThemeColor;
+declare const MindColorfulThemeColor: MindThemeColor;
+declare const MindSoftThemeColor: MindThemeColor;
+declare const MindRetroThemeColor: MindThemeColor;
+declare const MindDarkThemeColor: MindThemeColor;
+declare const MindStarryThemeColor: MindThemeColor;
+declare const MindThemeColors: MindThemeColor[];
+interface MindThemeColor extends ThemeColor {
+    mode: ThemeColorMode | string;
+    branchColors: string[];
+    rootFill: string;
+    rootTextColor: string;
+}
+declare const MindThemeColor: {
+    isMindThemeColor(value: any): value is MindThemeColor;
+};
+
+interface WithMindOptions extends WithPluginOptions {
+    emojiPadding: number;
+    spaceBetweenEmojis: number;
+}
+
+declare enum AbstractHandlePosition {
+    start = "start",
+    end = "end"
+}
+declare enum AbstractResizeState {
+    start = "start",
+    resizing = "resizing",
+    end = "end"
+}
+interface PlaitAbstractBoard extends PlaitOptionsBoard {
+    onAbstractResize?: (state: AbstractResizeState) => void;
+}
+type AbstractRefs = Map<MindElement, Pick<AbstractNode, 'start' | 'end'>>;
+
+interface PlaitMindBoard extends PlaitAbstractBoard {
+}
+
+interface PlaitMindEmojiBoard {
+    renderEmoji: (container: Element | DocumentFragment, props: EmojiProps) => EmojiComponentRef;
+}
+declare const withEmoji: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitMindEmojiBoard;
+type EmojiComponentRef = RenderComponentRef<EmojiProps>;
+interface EmojiProps {
+    board: PlaitBoard;
+    emojiItem: EmojiItem;
+    element: MindElement<EmojiData>;
+    fontSize: number;
+}
+
+declare class EmojiGenerator {
+    private board;
+    emojiComponentRef: EmojiComponentRef | null;
+    constructor(board: PlaitMindEmojiBoard & PlaitBoard);
+    draw(container: Element | DocumentFragment, emoji: EmojiItem, element: MindElement<EmojiData>): void;
+    destroy(): void;
+}
+declare class NodeEmojisGenerator {
+    private board;
+    static key: string;
+    emojiGenerators: EmojiGenerator[];
+    g?: SVGGElement;
+    constructor(board: PlaitMindBoard);
+    drawEmojis(element: MindElement): SVGGElement | undefined;
+    destroy(): void;
+}
+
+interface ActiveData {
+    selected: boolean;
+}
+declare class NodeActiveGenerator extends Generator<MindElement, ActiveData> {
+    static key: string;
+    abstractOutlineG?: SVGGElement;
+    canDraw(element: MindElement<BaseData>, data: ActiveData): boolean;
+    draw(element: MindElement<BaseData>, data: ActiveData): SVGGElement;
+    updateAbstractOutline(element: MindElement, activeHandlePosition?: AbstractHandlePosition, resizingLocation?: number): void;
+}
+
+interface ShapeData {
+    node: MindNode;
+}
+declare class NodeShapeGenerator extends Generator<MindElement, ShapeData> {
+    constructor(board: PlaitBoard);
+    canDraw(element: MindElement, data: ShapeData): boolean;
+    draw(element: MindElement, data: ShapeData): SVGGElement;
+}
+
+interface NodeMoreExtraData {
+    isSelected: boolean;
+    isHit?: boolean;
+    isHitAwarenessRectangle?: boolean | null;
+    isHitCollapseArea?: boolean;
+    isHitExpandArea?: boolean;
+    isHitAddArea?: boolean;
+    isShowCollapseAnimation?: boolean;
+    isShowAddAnimation?: boolean;
+    isHitStandardLeftAddArea?: boolean;
+    isHitStandardLeftAwarenessRectangle?: boolean;
+}
+declare class NodeMoreGenerator extends Generator<MindElement, NodeMoreExtraData> {
+    static key: string;
+    collapseOrAddG: SVGGElement | undefined | null;
+    expandG: SVGGElement | undefined | null;
+    canDraw(element: MindElement<BaseData>, extraData: NodeMoreExtraData): boolean;
+    draw(element: MindElement<BaseData>, extraData: NodeMoreExtraData): SVGGElement;
+    toggleCollapseAndAdd(center: Point, addCenter: Point | null, standardLeftAddCenter: Point | null | undefined, stroke: string, parentG: SVGGElement, isShowCollapse: boolean, isShowAdd: boolean, isShowStandardLeftAdd: boolean, isHitAddArea: boolean, isHitStandardLeftAdd: boolean, isShowCollapseAnimation: boolean, isShowAddAnimation: boolean): void;
+    toggleExpandBadge(element: MindElement, moreStartAndEnd: [Point, Point], center: Point, stroke: string, parentG: SVGGElement, isCollapsed: boolean, isHoveredExpandIcon: boolean): void;
+}
+
+declare class MindNodeComponent extends CommonElementFlavour<MindElement, PlaitMindBoard> implements OnContextChanged<MindElement, PlaitMindBoard> {
+    roughSVG: RoughSVG;
+    node: MindNode;
+    index: number;
+    shapeG: SVGGElement | null;
+    linkLineG?: SVGGElement;
+    nodeEmojisGenerator: NodeEmojisGenerator;
+    nodeShapeGenerator: NodeShapeGenerator;
+    imageGenerator: ImageGenerator<MindElement<ImageData>>;
+    activeGenerator: NodeActiveGenerator;
+    nodeMoreGenerator: NodeMoreGenerator;
+    get textManage(): TextManage;
+    constructor();
+    initializeGenerator(): void;
+    initialize(): void;
+    onContextChanged(value: PlaitPluginElementContext<MindElement, PlaitMindBoard>, previous: PlaitPluginElementContext<MindElement, PlaitMindBoard>): void;
+    drawEmojis(): void;
+    drawLink(): void;
+    drawTopic(): void;
+    updateTopic(): void;
+    trackBy: (index: number, node: MindNode) => string;
+    destroy(): void;
+}
+
+declare class PlaitMindComponent extends MindNodeComponent implements BeforeContextChange<PlaitMind> {
+    root: MindNode;
+    initialize(): void;
+    beforeContextChange(value: PlaitPluginElementContext<PlaitMind>): void;
+    updateMindLayout(element?: _plait_mind.MindElement<_plait_mind.BaseData>): void;
+    updateMindNodeLocation(element: PlaitMind): void;
+}
+
+declare function getRectangleByNode(node: MindNode): RectangleClient;
+declare function getRectangleByElement(board: PlaitMindBoard, element: MindElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+declare function isHitMindElement(board: PlaitBoard, point: Point, element: MindElement): boolean;
+
+declare function getEmojiRectangle(board: PlaitMindBoard, element: MindElement<EmojiData>): RectangleClient;
+declare function getEmojiForeignRectangle(board: PlaitMindBoard, element: MindElement<EmojiData>): RectangleClient;
+declare const isHitEmojis: (board: PlaitBoard, element: MindElement<EmojiData>, point: Point) => boolean;
+
+declare function getTopicRectangleByNode(board: PlaitMindBoard, node: MindNode): {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};
+declare function getTopicRectangleByElement(board: PlaitMindBoard, nodeRectangle: RectangleClient, element: MindElement): {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};
+
+declare function getImageForeignRectangle(board: PlaitMindBoard, element: MindElement<ImageData>): RectangleClient;
+declare const isHitImage: (board: PlaitBoard, element: MindElement<ImageData>, point: Point) => boolean;
+declare const getHitImageResizeHandleDirection: (board: PlaitBoard, element: MindElement<ImageData>, point: Point) => {
+    rectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    handle: _plait_common.ResizeHandle;
+    cursorClass: _plait_core.ResizeCursorClass;
+} | undefined;
+
+declare const MIND_ELEMENT_TO_NODE: WeakMap<MindElement<_plait_mind.BaseData>, MindNode>;
+
+declare const getChildrenCount: (element: MindElement) => number;
+declare const isChildElement: (origin: MindElement, child: MindElement) => boolean;
+declare const getFirstLevelElement: (elements: MindElement[]) => MindElement<_plait_mind.BaseData>[];
+declare const isChildRight: (parent: MindNode, child: MindNode) => boolean;
+declare const isChildUp: (parent: MindNode, child: MindNode) => boolean;
+declare const copyNewNode: (node: MindElement) => MindElement<_plait_mind.BaseData>;
+declare const insertMindElement: (board: PlaitMindBoard, inheritNode: MindElement, path: Path) => void;
+declare const findLastChild: (child: MindNode) => MindNode;
+declare const divideElementByParent: (elements: MindElement[]) => {
+    parentElements: MindElement<_plait_mind.BaseData>[];
+    abstractIncludedGroups: MindElement<_plait_mind.BaseData>[][];
+};
+declare const getDefaultFontSizeForMindElement: (element: MindElement) => 18 | 14;
+
+declare const getBranchDirectionsByLayouts: (branchLayouts: MindLayoutType[]) => LayoutDirection[];
+declare const isCorrectLayout: (root: MindElement, layout: MindLayoutType) => boolean;
+declare const isMixedLayout: (parentLayout: MindLayoutType, layout: MindLayoutType) => boolean;
+declare const getInCorrectLayoutDirection: (rootLayout: MindLayoutType, layout: MindLayoutType) => LayoutDirection | undefined;
+declare const correctLayoutByDirection: (layout: MindLayoutType, direction: LayoutDirection) => MindLayoutType;
+declare const getLayoutDirection: (root: MindElement) => LayoutDirection[];
+declare const getDefaultLayout: () => MindLayoutType;
+declare const getAvailableSubLayoutsByLayoutDirections: (directions: LayoutDirection[]) => MindLayoutType[];
+declare const getLayoutReverseDirection: (layoutDirection: LayoutDirection) => LayoutDirection;
+declare const getRootLayout: (root: MindElement) => MindLayoutType;
+
+declare const adjustRootToNode: (board: PlaitBoard, node: MindElement) => MindElement<_plait_mind.BaseData>;
+declare const adjustAbstractToNode: (node: MindElement) => MindElement<_plait_mind.BaseData>;
+declare const adjustNodeToRoot: (board: PlaitMindBoard, node: MindElement) => MindElement;
+
+declare const createEmptyMind: (board: PlaitBoard, point: Point) => MindElement<_plait_mind.BaseData>;
+declare const createMindElement: (text: string | Element$1, options: InheritAttribute) => MindElement<_plait_mind.BaseData>;
+interface InheritAttribute {
+    fill?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: number;
+    shape?: MindElementShape;
+    layout?: MindLayoutType;
+    branchColor?: string;
+    branchWidth?: number;
+    branchShape?: BranchShape;
+}
+declare const INHERIT_ATTRIBUTE_KEYS: string[];
+
+declare function editTopic(element: MindElement): void;
+declare const getSelectedMindElements: (board: PlaitBoard, elements?: PlaitElement[]) => MindElement[];
+
+declare const addImageFocus: (board: PlaitBoard, element: MindElement<ImageData>) => void;
+declare const removeImageFocus: (board: PlaitBoard, element: MindElement<ImageData>) => void;
+
 /**
- * Generated bundle index. Do not edit.
+ * 1. return new node height if height changed
+ * 2. new height is effected by zoom
  */
-/// <amd-module name="@plait/mind" />
-export * from './public-api';
+declare const getNewNodeHeight: (board: PlaitBoard, element: MindElement, newNodeDynamicWidth: number) => number | undefined;
+
+/**
+ * Processing of branch color, width, style, etc. of the mind node
+ */
+
+declare const getBranchColorByMindElement: (board: PlaitBoard, element: MindElement) => any;
+declare const getBranchShapeByMindElement: (board: PlaitBoard, element: MindElement) => any;
+declare const getBranchWidthByMindElement: (board: PlaitBoard, element: MindElement) => any;
+declare const getAbstractBranchWidth: (board: PlaitBoard, element: MindElement) => number;
+declare const getAbstractBranchColor: (board: PlaitBoard, element: MindElement) => string | undefined;
+declare const getNextBranchColor: (board: PlaitBoard, root: MindElement) => string;
+declare const getDefaultBranchColor: (board: PlaitBoard, element: MindElement) => string;
+declare const getDefaultBranchColorByIndex: (board: PlaitBoard, index: number) => string;
+declare const getMindThemeColor: (board: PlaitBoard) => MindThemeColor;
+
+declare const getStrokeColorByElement: (board: PlaitBoard, element: MindElement) => any;
+declare const getStrokeStyleByElement: (board: PlaitBoard, element: MindElement) => StrokeStyle;
+declare const getStrokeWidthByElement: (board: PlaitBoard, element: MindElement) => number;
+declare const getFillByElement: (board: PlaitBoard, element: MindElement) => string;
+declare const getShapeByElement: (board: PlaitBoard, element: MindElement) => MindElementShape;
+
+declare const addActiveOnDragOrigin: (activeElement: MindElement) => void;
+declare const removeActiveOnDragOrigin: (activeElement: MindElement) => void;
+declare const setMindDragging: (board: PlaitBoard, state: boolean) => void;
+declare const hasPreviousOrNextOfDropPath: (parent: MindElement, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}, dropPath: Path) => {
+    hasPreviousNode: boolean;
+    hasNextNode: boolean;
+};
+declare const isDropStandardRight: (parent: MindElement, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}) => boolean;
+
+declare const directionCorrector: (board: PlaitBoard, node: MindNode, detectResults: DetectResult[]) => DetectResult[] | null;
+declare const getAllowedDirection: (detectResults: DetectResult[], illegalDirections: DetectResult[]) => DetectResult[] | null;
+declare const detectDropTarget: (board: PlaitBoard, detectPoint: Point, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+} | null, activeElements: MindElement[]) => {
+    target: MindElement;
+    detectResult: DetectResult;
+} | null;
+declare const directionDetector: (targetNode: MindNode, centerPoint: Point) => DetectResult[] | null;
+declare const isValidTarget: (origin: MindElement, target: MindElement) => boolean;
+declare const getPathByDropTarget: (board: PlaitBoard, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}) => Path;
+
+declare const drawFakeDragNode: (board: PlaitBoard, element: MindElement, offsetX: number, offsetY: number) => SVGGElement;
+declare const drawFakeDropNode: (board: PlaitBoard, dropTarget: {
+    target: MindElement;
+    detectResult: DetectResult;
+}, path: Path) => SVGGElement;
+
+declare const separateChildren: (parentElement: MindElement) => {
+    leftChildren: MindElement<_plait_mind.BaseData>[];
+    rightChildren: MindElement<_plait_mind.BaseData>[];
+};
+declare const isSetAbstract: (element: PlaitElement) => boolean;
+declare const canSetAbstract: (element: PlaitElement) => boolean;
+declare const getCorrespondingAbstract: (element: MindElement) => MindElement<_plait_mind.BaseData> | undefined;
+declare const getBehindAbstracts: (element: MindElement) => MindElement<_plait_mind.BaseData>[];
+/**
+ * return corresponding abstract that is not child of elements
+ */
+declare const getOverallAbstracts: (board: PlaitBoard, elements: MindElement[]) => (MindElement & AbstractNode)[];
+interface AbstractRef {
+    abstract: MindElement & AbstractNode;
+    references: MindElement[];
+}
+/**
+ * abstract node is valid when elements contains at least one element it is referenced with
+ */
+declare const getValidAbstractRefs: (board: PlaitBoard, elements: MindElement[]) => AbstractRef[];
+declare function getRelativeStartEndByAbstractRef(abstractRef: AbstractRef, elements: MindElement[]): {
+    start: number;
+    end: number;
+};
+declare const insertElementHandleAbstract: (board: PlaitBoard, path: Path, step?: number, isExtendPreviousNode?: boolean, effectedAbstracts?: Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>) => Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>;
+declare const deleteElementHandleAbstract: (board: PlaitBoard, deletableElements: MindElement[], effectedAbstracts?: Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>) => Map<MindElement<_plait_mind.BaseData>, Pick<AbstractNode, "start" | "end">>;
+declare const isChildOfAbstract: (board: PlaitBoard, element: MindElement) => boolean;
+
+declare const getRectangleByResizingLocation: (abstractRectangle: RectangleClient, location: number, activeHandlePosition: AbstractHandlePosition, isHorizontal: boolean) => {
+    y: number;
+    height: number;
+    x: number;
+    width: number;
+};
+declare const getLocationScope: (board: PlaitBoard, handlePosition: AbstractHandlePosition, parentChildren: MindElement[], element: MindElement, parent: LayoutNode, isHorizontal: boolean) => {
+    max: number;
+    min: number;
+};
+declare const getHitAbstractHandle: (board: PlaitBoard, element: MindElement, point: Point) => AbstractHandlePosition | undefined;
+declare const getAbstractHandleRectangle: (rectangle: RectangleClient, isHorizontal: boolean, position: AbstractHandlePosition) => {
+    y: number;
+    height: number;
+    x: number;
+    width: number;
+};
+declare function findLocationLeftIndex(board: PlaitBoard, parentChildren: MindElement[], location: number, isHorizontal: boolean): number;
+declare function handleTouchedAbstract(board: PlaitBoard, touchedAbstract: MindElement | undefined, endPoint: Point): MindElement<_plait_mind.BaseData> | undefined;
+
+declare const isInRightBranchOfStandardLayout: (selectedElement: MindElement) => boolean;
+interface RightNodeCountRef {
+    path: Path;
+    rightNodeCount: number;
+}
+declare const insertElementHandleRightNodeCount: (board: PlaitBoard, path: Path, insertCount: number, effectedRightNodeCount?: RightNodeCountRef[]) => RightNodeCountRef[];
+declare const deleteElementsHandleRightNodeCount: (board: PlaitBoard, deletableElements: MindElement[], effectedRightNodeCount?: RightNodeCountRef[]) => RightNodeCountRef[];
+
+declare const NodeSpace: {
+    getNodeWidth(board: PlaitMindBoard, element: MindElement): number;
+    getNodeHeight(board: PlaitMindBoard, element: MindElement): number;
+    getTopicDynamicWidth(board: PlaitMindBoard, element: MindElement): number;
+    getTopicHeight(board: PlaitMindBoard, element: MindElement): number;
+    getTopicMaxDynamicWidth(board: PlaitMindBoard, element: MindElement): number;
+    getNodeResizableMinWidth(board: PlaitMindBoard, element: MindElement): number;
+    getNodeTopicMinWidth(board: PlaitMindBoard, element: MindElement): number;
+    getTextLeftSpace(board: PlaitMindBoard, element: MindElement): number;
+    getTextTopSpace(board: PlaitMindBoard, element: MindElement): number;
+    getImageTopSpace(board: PlaitMindBoard, element: MindElement): number;
+    getEmojiLeftSpace(board: PlaitMindBoard, element: MindElement<EmojiData>): number;
+    getEmojiTopSpace(board: PlaitMindBoard, element: MindElement): number;
+};
+declare const getFontSizeByMindElement: (board: PlaitBoard, element: MindElement) => number;
+declare const normalizeWidthAndHeight: (board: PlaitMindBoard, element: MindElement, width: number, height: number) => {
+    width: number;
+    height: number;
+};
+
+declare function getEmojisWidthHeight(board: PlaitMindBoard, element: MindElement<EmojiData>): {
+    width: number;
+    height: any;
+};
+declare function getEmojiFontSize(element: MindElement<EmojiData>): number;
+
+declare const getLayoutOptions: (board: PlaitMindBoard) => LayoutOptions;
+
+declare function findNewChildNodePath(board: PlaitBoard, element: PlaitElement): number[];
+declare function findNewRightChildNodePath(board: PlaitBoard, element: PlaitMind, rightNodeCount: number): number[];
+declare function findNewSiblingNodePath(board: PlaitBoard, element: PlaitElement): Path$1;
+
+declare const MIND_CENTRAL_TEXT = "\u4E2D\u5FC3\u4E3B\u9898";
+declare const ABSTRACT_NODE_TEXT = "\u6982\u8981";
+declare const getDefaultMindNameText: (board: PlaitBoard) => string;
+declare const getAbstractNodeText: (board: PlaitBoard) => string;
+
+declare const withMind: (baseBoard: PlaitBoard) => PlaitBoard & _plait_mind.PlaitMindEmojiBoard;
+
+declare const withMindExtend: (board: PlaitBoard) => PlaitBoard & PlaitMindBoard;
+
+declare const WithMindPluginKey = "plait-mind-plugin-key";
+declare const BASE = 4;
+declare const PRIMARY_COLOR = "#6698FF";
+declare const GRAY_COLOR = "#AAAAAA";
+declare const STROKE_WIDTH = 2;
+declare const RESIZE_HANDLE_BUFFER_DISTANCE = 8;
+declare const NODE_MORE_LINE_DISTANCE = 10;
+declare const NODE_MORE_STROKE_WIDTH = 2;
+declare const NODE_MORE_ICON_DIAMETER = 20;
+declare const NODE_MORE_BRIDGE_DISTANCE = 10;
+declare const NODE_ADD_CIRCLE_COLOR: string;
+declare const NODE_ADD_HOVER_COLOR = "#6698FF";
+declare const NODE_ADD_INNER_CROSS_COLOR = "white";
+declare const DEFAULT_MIND_IMAGE_WIDTH = 240;
+declare enum MindI18nKey {
+    mindCentralText = "mind-center-text",
+    abstractNodeText = "abstract-node-text"
+}
+
+declare const DefaultAbstractNodeStyle: {
+    branch: {
+        color: string;
+        width: number;
+    };
+    shape: {
+        strokeColor: string;
+        strokeWidth: number;
+    };
+};
+declare const DefaultNodeStyle: {
+    branch: {
+        width: number;
+    };
+    shape: {
+        rectangleRadius: number;
+        strokeWidth: number;
+        fill: string;
+    };
+};
+
+declare const TOPIC_FONT_SIZE = 14;
+declare const ROOT_TOPIC_FONT_SIZE = 18;
+declare const TOPIC_DEFAULT_MAX_WORD_COUNT = 34;
+
+declare const ABSTRACT_HANDLE_COLOR = "#6698FF80";
+declare const ABSTRACT_INCLUDED_OUTLINE_OFFSET = 3.5;
+declare const ABSTRACT_HANDLE_LENGTH = 10;
+declare const ABSTRACT_HANDLE_MASK_WIDTH = 8;
+
+declare const MindQueries: {
+    getAvailableSubLayoutsByElement: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement) => _plait_layouts.MindLayoutType[] | undefined;
+    getBranchLayouts: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement) => _plait_layouts.MindLayoutType[];
+    getCorrectLayoutByElement: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement) => _plait_layouts.MindLayoutType;
+};
+
+declare const MindTransforms: {
+    setLayout: (board: _plait_core.PlaitBoard, type: _plait_layouts.MindLayoutType) => void;
+    setShape: (board: _plait_core.PlaitBoard, shape: _plait_mind.MindElementShape) => void;
+    setBranchShape: (board: _plait_core.PlaitBoard, branchShape: _plait_mind.BranchShape) => void;
+    setBranchWidth: (board: _plait_core.PlaitBoard, branchWidth: number) => void;
+    setBranchColor: (board: _plait_core.PlaitBoard, branchColor: string) => void;
+    setTopic: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement, topic?: slate.Element) => void;
+    setNodeManualWidth: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement, width: number) => void;
+    addEmoji: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement, emojiItem: _plait_mind.EmojiItem) => void;
+    removeEmoji: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement<_plait_mind.EmojiData>, emojiItem: _plait_mind.EmojiItem) => void;
+    replaceEmoji: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement<_plait_mind.EmojiData>, oldEmoji: _plait_mind.EmojiItem, newEmoji: _plait_mind.EmojiItem) => void;
+    insertAbstract: (board: _plait_core.PlaitBoard, elements: _plait_core.PlaitElement[]) => void;
+    setAbstractsByRefs: (board: _plait_core.PlaitBoard, abstractRefs: _plait_mind.AbstractRefs) => void;
+    setAbstractByStandardLayout: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement) => void;
+    insertNodes: (board: _plait_core.PlaitBoard, elements: _plait_mind.MindElement[], path: slate.Path) => void;
+    insertAbstractNodes: (board: _plait_core.PlaitBoard, validAbstractRefs: _plait_mind.AbstractRef[], elements: _plait_mind.MindElement[], path: slate.Path) => void;
+    setRightNodeCountByRefs: (board: _plait_core.PlaitBoard, refs: _plait_mind.RightNodeCountRef[]) => void;
+    removeImage: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement<_plait_mind.ImageData>) => void;
+    setImage: (board: _plait_core.PlaitBoard, element: _plait_mind.MindElement, imageItem: _plait_common.CommonImageItem) => void;
+    insertChildNode: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement) => void;
+    insertSiblingNode: (board: _plait_mind.PlaitMindBoard, element: _plait_mind.MindElement) => void;
+    insertMind: (board: _plait_mind.PlaitMindBoard, mind: _plait_mind.MindElement) => void;
+};
+
+declare abstract class MindEmojiBaseComponent {
+    fontSize: number;
+    emojiItem: EmojiItem;
+    board: PlaitBoard;
+    element: MindElement<EmojiData>;
+    abstract nativeElement(): HTMLElement;
+}
+
+export { ABSTRACT_HANDLE_COLOR, ABSTRACT_HANDLE_LENGTH, ABSTRACT_HANDLE_MASK_WIDTH, ABSTRACT_INCLUDED_OUTLINE_OFFSET, ABSTRACT_NODE_TEXT, AbstractHandlePosition, AbstractResizeState, BASE, BranchShape, DEFAULT_MIND_IMAGE_WIDTH, DefaultAbstractNodeStyle, DefaultNodeStyle, GRAY_COLOR, INHERIT_ATTRIBUTE_KEYS, LayoutDirection, LayoutDirectionsMap, MIND_CENTRAL_TEXT, MIND_ELEMENT_TO_NODE, MindColorfulThemeColor, MindDarkThemeColor, MindDefaultThemeColor, MindElement, MindElementShape, MindEmojiBaseComponent, MindI18nKey, MindNode, MindNodeComponent, MindPointerType, MindQueries, MindRetroThemeColor, MindSoftThemeColor, MindStarryThemeColor, MindThemeColor, MindThemeColors, MindTransforms, NODE_ADD_CIRCLE_COLOR, NODE_ADD_HOVER_COLOR, NODE_ADD_INNER_CROSS_COLOR, NODE_MORE_BRIDGE_DISTANCE, NODE_MORE_ICON_DIAMETER, NODE_MORE_LINE_DISTANCE, NODE_MORE_STROKE_WIDTH, NodeSpace, PRIMARY_COLOR, PlaitMind, PlaitMindComponent, RESIZE_HANDLE_BUFFER_DISTANCE, ROOT_TOPIC_FONT_SIZE, STROKE_WIDTH, TOPIC_DEFAULT_MAX_WORD_COUNT, TOPIC_FONT_SIZE, WithMindPluginKey, addActiveOnDragOrigin, addImageFocus, adjustAbstractToNode, adjustNodeToRoot, adjustRootToNode, canSetAbstract, copyNewNode, correctLayoutByDirection, createEmptyMind, createMindElement, deleteElementHandleAbstract, deleteElementsHandleRightNodeCount, detectDropTarget, directionCorrector, directionDetector, divideElementByParent, drawFakeDragNode, drawFakeDropNode, editTopic, findLastChild, findLocationLeftIndex, findNewChildNodePath, findNewRightChildNodePath, findNewSiblingNodePath, getAbstractBranchColor, getAbstractBranchWidth, getAbstractHandleRectangle, getAbstractNodeText, getAllowedDirection, getAvailableSubLayoutsByLayoutDirections, getBehindAbstracts, getBranchColorByMindElement, getBranchDirectionsByLayouts, getBranchShapeByMindElement, getBranchWidthByMindElement, getChildrenCount, getCorrespondingAbstract, getDefaultBranchColor, getDefaultBranchColorByIndex, getDefaultFontSizeForMindElement, getDefaultLayout, getDefaultMindNameText, getEmojiFontSize, getEmojiForeignRectangle, getEmojiRectangle, getEmojisWidthHeight, getFillByElement, getFirstLevelElement, getFontSizeByMindElement, getHitAbstractHandle, getHitImageResizeHandleDirection, getImageForeignRectangle, getInCorrectLayoutDirection, getLayoutDirection, getLayoutOptions, getLayoutReverseDirection, getLocationScope, getMindThemeColor, getNewNodeHeight, getNextBranchColor, getOverallAbstracts, getPathByDropTarget, getRectangleByElement, getRectangleByNode, getRectangleByResizingLocation, getRelativeStartEndByAbstractRef, getRootLayout, getSelectedMindElements, getShapeByElement, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getTopicRectangleByElement, getTopicRectangleByNode, getValidAbstractRefs, handleTouchedAbstract, hasPreviousOrNextOfDropPath, insertElementHandleAbstract, insertElementHandleRightNodeCount, insertMindElement, isChildElement, isChildOfAbstract, isChildRight, isChildUp, isCorrectLayout, isDropStandardRight, isHitEmojis, isHitImage, isHitMindElement, isInRightBranchOfStandardLayout, isMixedLayout, isSetAbstract, isValidTarget, normalizeWidthAndHeight, removeActiveOnDragOrigin, removeImageFocus, separateChildren, setMindDragging, withEmoji, withMind, withMindExtend };
+export type { AbstractRef, AbstractRefs, BaseData, BaseMindElement, CoordinateType, DetectResult, EmojiComponentRef, EmojiData, EmojiItem, EmojiProps, ExtendLayoutType, ExtendUnderlineCoordinateType, ImageData, InheritAttribute, LayoutDirectionMapType, PlaitAbstractBoard, PlaitMindBoard, PlaitMindEmojiBoard, RightNodeCountRef, RootBaseDirection, WithMindOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plait/mind",
-  "version": "0.91.0",
+  "version": "0.92.0-next.0",
   "peerDependencies": {},
   "dependencies": {
     "tslib": "^2.3.0"

package/constants/abstract-node.d.ts

@@ -1,4 +0,0 @@
-export declare const ABSTRACT_HANDLE_COLOR = "#6698FF80";
-export declare const ABSTRACT_INCLUDED_OUTLINE_OFFSET = 3.5;
-export declare const ABSTRACT_HANDLE_LENGTH = 10;
-export declare const ABSTRACT_HANDLE_MASK_WIDTH = 8;

package/constants/default.d.ts

@@ -1,18 +0,0 @@
-export declare const WithMindPluginKey = "plait-mind-plugin-key";
-export declare const BASE = 4;
-export declare const PRIMARY_COLOR = "#6698FF";
-export declare const GRAY_COLOR = "#AAAAAA";
-export declare const STROKE_WIDTH = 2;
-export declare const RESIZE_HANDLE_BUFFER_DISTANCE = 8;
-export declare const NODE_MORE_LINE_DISTANCE = 10;
-export declare const NODE_MORE_STROKE_WIDTH = 2;
-export declare const NODE_MORE_ICON_DIAMETER = 20;
-export declare const NODE_MORE_BRIDGE_DISTANCE = 10;
-export declare const NODE_ADD_CIRCLE_COLOR: string;
-export declare const NODE_ADD_HOVER_COLOR = "#6698FF";
-export declare const NODE_ADD_INNER_CROSS_COLOR = "white";
-export declare const DEFAULT_MIND_IMAGE_WIDTH = 240;
-export declare enum MindI18nKey {
-    mindCentralText = "mind-center-text",
-    abstractNodeText = "abstract-node-text"
-}

package/constants/index.d.ts

@@ -1,4 +0,0 @@
-export * from './default';
-export * from './node-style';
-export * from './node-topic-style';
-export * from './abstract-node';

package/constants/node-style.d.ts

@@ -1,20 +0,0 @@
-export declare const DefaultAbstractNodeStyle: {
-    branch: {
-        color: string;
-        width: number;
-    };
-    shape: {
-        strokeColor: string;
-        strokeWidth: number;
-    };
-};
-export declare const DefaultNodeStyle: {
-    branch: {
-        width: number;
-    };
-    shape: {
-        rectangleRadius: number;
-        strokeWidth: number;
-        fill: string;
-    };
-};

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

@@ -1,3 +0,0 @@
-export declare const TOPIC_FONT_SIZE = 14;
-export declare const ROOT_TOPIC_FONT_SIZE = 18;
-export declare const TOPIC_DEFAULT_MAX_WORD_COUNT = 34;