mind-elixir 5.0.0-beta.9 → 5.0.0

package/dist/types/index.d.ts

@@ -1,15 +1,14 @@
 import './index.less';
-import './iconfont/iconfont.js';
 import { LEFT, RIGHT, SIDE, DARK_THEME, THEME } from './const';
-import { findEle } from './utils/dom';
 import type { MindElixirData, MindElixirInstance, MindElixirMethods, Options } from './types/index';
-declare function MindElixir(this: MindElixirInstance, { el, direction, locale, draggable, editable, contextMenu, contextMenuOption, toolBar, keypress, mouseSelectionButton, selectionContainer, before, newTopicName, allowUndo, generateMainBranch, generateSubBranch, overflowHidden, theme, alignment, }: Options): void;
+import type { Topic } from './docs';
+declare function MindElixir(this: MindElixirInstance, { el, direction, locale, draggable, editable, contextMenu, toolBar, keypress, mouseSelectionButton, selectionContainer, before, newTopicName, allowUndo, generateMainBranch, generateSubBranch, overflowHidden, theme, alignment, scaleSensitivity, }: Options): void;
 declare namespace MindElixir {
     export var prototype: {
         init(this: MindElixirInstance, data: MindElixirData): Error | undefined;
         destroy(this: Partial<MindElixirInstance>): void;
-        exportSvg: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string | undefined) => Blob;
-        exportPng: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string | undefined) => Promise<Blob | null>;
+        exportSvg: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string) => Blob;
+        exportPng: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string) => Promise<Blob | null>;
         createSummary: (this: MindElixirInstance) => void;
         createSummaryFrom: (this: MindElixirInstance, summary: Omit<import("./summary").Summary, "id">) => void;
         removeSummary: (this: MindElixirInstance, id: string) => void;
@@ -18,33 +17,32 @@ declare namespace MindElixir {
         renderSummary: (this: MindElixirInstance) => void;
         editSummary: (this: MindElixirInstance, el: import("./summary").SummarySvgGroup) => void;
         renderArrow(this: MindElixirInstance): void;
-        editArrowLabel(this: MindElixirInstance, el: import("./types/dom").CustomSvg): void;
+        editArrowLabel(this: MindElixirInstance, el: import("./docs").CustomSvg): void;
         tidyArrow(this: MindElixirInstance): void;
-        createArrow: (this: MindElixirInstance, from: import("./types/dom").Topic, to: import("./types/dom").Topic, options?: import("./arrow").ArrowOptions) => void;
+        createArrow: (this: MindElixirInstance, from: Topic, to: Topic, options?: import("./arrow").ArrowOptions) => void;
         createArrowFrom: (this: MindElixirInstance, arrow: Omit<import("./arrow").Arrow, "id">) => void;
-        removeArrow: (this: MindElixirInstance, linkSvg?: import("./types/dom").CustomSvg | undefined) => void;
-        selectArrow: (this: MindElixirInstance, link: import("./types/dom").CustomSvg) => void;
+        removeArrow: (this: MindElixirInstance, linkSvg?: import("./docs").CustomSvg) => void;
+        selectArrow: (this: MindElixirInstance, link: import("./docs").CustomSvg) => void;
         unselectArrow: (this: MindElixirInstance) => void;
-        rmSubline: (this: MindElixirInstance, tpc: import("./types/dom").Topic) => Promise<void>;
-        reshapeNode: (this: MindElixirInstance, tpc: import("./types/dom").Topic, patchData: Partial<import("./types/index").NodeObj>) => Promise<void>;
-        insertSibling: (this: MindElixirInstance, type: "before" | "after", el?: import("./types/dom").Topic | undefined, node?: import("./types/index").NodeObj | undefined) => Promise<void>;
-        insertParent: (this: MindElixirInstance, el?: import("./types/dom").Topic | undefined, node?: import("./types/index").NodeObj | undefined) => Promise<void>;
-        addChild: (this: MindElixirInstance, el?: import("./types/dom").Topic | undefined, node?: import("./types/index").NodeObj | undefined) => Promise<void>;
-        copyNode: (this: MindElixirInstance, node: import("./types/dom").Topic, to: import("./types/dom").Topic) => Promise<void>;
-        copyNodes: (this: MindElixirInstance, tpcs: import("./types/dom").Topic[], to: import("./types/dom").Topic) => Promise<void>;
-        moveUpNode: (this: MindElixirInstance, el?: import("./types/dom").Topic | undefined) => Promise<void>;
-        moveDownNode: (this: MindElixirInstance, el?: import("./types/dom").Topic | undefined) => Promise<void>;
-        removeNode: (this: MindElixirInstance, el?: import("./types/dom").Topic | undefined) => Promise<void>;
-        removeNodes: (this: MindElixirInstance, tpcs: import("./types/dom").Topic[]) => Promise<void>;
-        moveNodeIn: (this: MindElixirInstance, from: import("./types/dom").Topic[], to: import("./types/dom").Topic) => Promise<void>;
-        moveNodeBefore: (this: MindElixirInstance, from: import("./types/dom").Topic[], to: import("./types/dom").Topic) => Promise<void>;
-        moveNodeAfter: (this: MindElixirInstance, from: import("./types/dom").Topic[], to: import("./types/dom").Topic) => Promise<void>;
-        beginEdit: (this: MindElixirInstance, el?: import("./types/dom").Topic | undefined) => Promise<void>;
-        setNodeTopic: (this: MindElixirInstance, el: import("./types/dom").Topic, topic: string) => Promise<void>;
-        selectNode: (this: MindElixirInstance, targetElement: import("./types/dom").Topic, isNewNode?: boolean | undefined, e?: MouseEvent | undefined) => void;
-        unselectNode: (this: MindElixirInstance) => void;
-        selectNodes: (this: MindElixirInstance, tpc: import("./types/dom").Topic[]) => void;
-        unselectNodes: (this: MindElixirInstance) => void;
+        rmSubline: (this: MindElixirInstance, tpc: Topic) => Promise<void>;
+        reshapeNode: (this: MindElixirInstance, tpc: Topic, patchData: Partial<import("./docs").NodeObj>) => Promise<void>;
+        insertSibling: (this: MindElixirInstance, type: "before" | "after", el?: Topic | undefined, node?: import("./docs").NodeObj | undefined) => Promise<void>;
+        insertParent: (this: MindElixirInstance, el?: Topic | undefined, node?: import("./docs").NodeObj | undefined) => Promise<void>;
+        addChild: (this: MindElixirInstance, el?: Topic | undefined, node?: import("./docs").NodeObj | undefined) => Promise<void>;
+        copyNode: (this: MindElixirInstance, node: Topic, to: Topic) => Promise<void>;
+        copyNodes: (this: MindElixirInstance, tpcs: Topic[], to: Topic) => Promise<void>;
+        moveUpNode: (this: MindElixirInstance, el?: Topic | undefined) => Promise<void>;
+        moveDownNode: (this: MindElixirInstance, el?: Topic | undefined) => Promise<void>;
+        removeNodes: (this: MindElixirInstance, tpcs: Topic[]) => Promise<void>;
+        moveNodeIn: (this: MindElixirInstance, from: Topic[], to: Topic) => Promise<void>;
+        moveNodeBefore: (this: MindElixirInstance, from: Topic[], to: Topic) => Promise<void>;
+        moveNodeAfter: (this: MindElixirInstance, from: Topic[], to: Topic) => Promise<void>;
+        beginEdit: (this: MindElixirInstance, el?: Topic | undefined) => Promise<void>;
+        setNodeTopic: (this: MindElixirInstance, el: Topic, topic: string) => Promise<void>;
+        scrollIntoView: (this: MindElixirInstance, el: HTMLElement) => void;
+        selectNode: (this: MindElixirInstance, tpc: Topic, isNewNode?: boolean, e?: MouseEvent) => void;
+        selectNodes: (this: MindElixirInstance, tpc: Topic[]) => void;
+        unselectNodes: (this: MindElixirInstance, tpc: Topic[]) => void;
         clearSelection: (this: MindElixirInstance) => void;
         getDataString: (this: MindElixirInstance) => string;
         getData: (this: MindElixirInstance) => MindElixirData;
@@ -58,46 +56,47 @@ declare namespace MindElixir {
         move: (this: MindElixirInstance, dx: number, dy: number) => void;
         toCenter: (this: MindElixirInstance) => void;
         install: (this: MindElixirInstance, plugin: (instance: MindElixirInstance) => void) => void;
-        focusNode: (this: MindElixirInstance, el: import("./types/dom").Topic) => void;
+        focusNode: (this: MindElixirInstance, el: Topic) => void;
         cancelFocus: (this: MindElixirInstance) => void;
         initLeft: (this: MindElixirInstance) => void;
         initRight: (this: MindElixirInstance) => void;
         initSide: (this: MindElixirInstance) => void;
         setLocale: (this: MindElixirInstance, locale: import("./i18n").Locale) => void;
-        expandNode: (this: MindElixirInstance, el: import("./types/dom").Topic, isExpand?: boolean | undefined) => void;
-        refresh: (this: MindElixirInstance, data?: MindElixirData | undefined) => void;
-        getObjById: (id: string, data: import("./types/index").NodeObj) => import("./types/index").NodeObj | null;
-        generateNewObj: (this: MindElixirInstance) => import("./types/index").NodeObjExport;
+        expandNode: (this: MindElixirInstance, el: Topic, isExpand?: boolean) => void;
+        expandNodeAll: (this: MindElixirInstance, el: Topic, isExpand?: boolean) => void;
+        refresh: (this: MindElixirInstance, data?: MindElixirData) => void;
+        getObjById: (id: string, data: import("./docs").NodeObj) => import("./docs").NodeObj | null;
+        generateNewObj: (this: MindElixirInstance) => import("./docs").NodeObjExport;
         layout: (this: MindElixirInstance) => void;
-        linkDiv: (this: MindElixirInstance, mainNode?: import("./types/dom").Wrapper | undefined) => void;
-        editTopic: (this: MindElixirInstance, el: import("./types/dom").Topic) => void;
-        createWrapper: (this: MindElixirInstance, nodeObj: import("./types/index").NodeObj, omitChildren?: boolean | undefined) => {
-            grp: import("./types/dom").Wrapper;
-            top: import("./types/dom").Parent;
-            tpc: import("./types/dom").Topic;
+        linkDiv: (this: MindElixirInstance, mainNode?: import("./docs").Wrapper) => void;
+        editTopic: (this: MindElixirInstance, el: Topic) => void;
+        createWrapper: (this: MindElixirInstance, nodeObj: import("./docs").NodeObj, omitChildren?: boolean) => {
+            grp: import("./docs").Wrapper;
+            top: import("./docs").Parent;
+            tpc: Topic;
         };
-        createParent: (this: MindElixirInstance, nodeObj: import("./types/index").NodeObj) => {
-            p: import("./types/dom").Parent;
-            tpc: import("./types/dom").Topic;
+        createParent: (this: MindElixirInstance, nodeObj: import("./docs").NodeObj) => {
+            p: import("./docs").Parent;
+            tpc: Topic;
         };
-        createChildren: (this: MindElixirInstance, wrappers: import("./types/dom").Wrapper[]) => import("./types/dom").Children;
-        createTopic: (this: MindElixirInstance, nodeObj: import("./types/index").NodeObj) => import("./types/dom").Topic;
-        findEle: (id: string, instance?: MindElixirInstance | undefined) => import("./types/dom").Topic;
-        changeTheme: (this: MindElixirInstance, theme: import("./types/index").Theme, shouldRefresh?: boolean) => void;
+        createChildren: (this: MindElixirInstance, wrappers: import("./docs").Wrapper[]) => import("./docs").Children;
+        createTopic: (this: MindElixirInstance, nodeObj: import("./docs").NodeObj) => Topic;
+        findEle: (this: MindElixirInstance, id: string, el?: HTMLElement) => Topic;
+        changeTheme: (this: MindElixirInstance, theme: import("./docs").Theme, shouldRefresh?: boolean) => void;
     };
     export var LEFT: number;
     export var RIGHT: number;
     export var SIDE: number;
-    export var THEME: import("./types/index").Theme;
-    export var DARK_THEME: import("./types/index").Theme;
+    export var THEME: import("./docs").Theme;
+    export var DARK_THEME: import("./docs").Theme;
     export var version: any;
-    export var E: (id: string, instance?: MindElixirInstance | undefined) => import("./types/dom").Topic;
+    export var E: (this: MindElixirInstance, id: string, el?: HTMLElement) => Topic;
     var _a: (topic: string) => MindElixirData;
     export { _a as new };
 }
 export interface MindElixirCtor {
     new (options: Options): MindElixirInstance;
-    E: typeof findEle;
+    E: (id: string, el?: HTMLElement) => Topic;
     new: typeof MindElixir.new;
     version: string;
     LEFT: typeof LEFT;

package/dist/types/interact.d.ts

@@ -1,10 +1,10 @@
 import type { Locale } from './i18n';
 import type { Topic } from './types/dom';
 import type { MindElixirData, MindElixirInstance } from './types/index';
-export declare const selectNode: (this: MindElixirInstance, targetElement: Topic, isNewNode?: boolean, e?: MouseEvent) => void;
-export declare const unselectNode: (this: MindElixirInstance) => void;
+export declare const scrollIntoView: (this: MindElixirInstance, el: HTMLElement) => void;
+export declare const selectNode: (this: MindElixirInstance, tpc: Topic, isNewNode?: boolean, e?: MouseEvent) => void;
 export declare const selectNodes: (this: MindElixirInstance, tpc: Topic[]) => void;
-export declare const unselectNodes: (this: MindElixirInstance) => void;
+export declare const unselectNodes: (this: MindElixirInstance, tpc: Topic[]) => void;
 export declare const clearSelection: (this: MindElixirInstance) => void;
 /**
  * @function
@@ -123,6 +123,7 @@ export declare const initSide: (this: MindElixirInstance) => void;
  */
 export declare const setLocale: (this: MindElixirInstance, locale: Locale) => void;
 export declare const expandNode: (this: MindElixirInstance, el: Topic, isExpand?: boolean) => void;
+export declare const expandNodeAll: (this: MindElixirInstance, el: Topic, isExpand?: boolean) => void;
 /**
  * @function
  * @instance

package/dist/types/linkDiv.d.ts

@@ -1,5 +1,5 @@
 import type { Wrapper } from './types/dom';
-import { type MindElixirInstance } from './types/index';
+import type { MindElixirInstance } from './types/index';
 /**
  * Link nodes with svg,
  * only link specific node if `mainNode` is present

package/dist/types/methods.d.ts

@@ -13,8 +13,8 @@ export type MindElixirMethods = typeof methods;
 declare const methods: {
     init(this: MindElixirInstance, data: MindElixirData): Error | undefined;
     destroy(this: Partial<MindElixirInstance>): void;
-    exportSvg: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string | undefined) => Blob;
-    exportPng: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string | undefined) => Promise<Blob | null>;
+    exportSvg: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string) => Blob;
+    exportPng: (this: MindElixirInstance, noForeignObject?: boolean, injectCss?: string) => Promise<Blob | null>;
     createSummary: (this: MindElixirInstance) => void;
     createSummaryFrom: (this: MindElixirInstance, summary: Omit<summary.Summary, "id">) => void;
     removeSummary: (this: MindElixirInstance, id: string) => void;
@@ -27,7 +27,7 @@ declare const methods: {
     tidyArrow(this: MindElixirInstance): void;
     createArrow: (this: MindElixirInstance, from: import("./index").Topic, to: import("./index").Topic, options?: arrow.ArrowOptions) => void;
     createArrowFrom: (this: MindElixirInstance, arrow: Omit<arrow.Arrow, "id">) => void;
-    removeArrow: (this: MindElixirInstance, linkSvg?: import("./index").CustomSvg | undefined) => void;
+    removeArrow: (this: MindElixirInstance, linkSvg?: import("./index").CustomSvg) => void;
     selectArrow: (this: MindElixirInstance, link: import("./index").CustomSvg) => void;
     unselectArrow: (this: MindElixirInstance) => void;
     rmSubline: (this: MindElixirInstance, tpc: import("./index").Topic) => Promise<void>;
@@ -39,17 +39,16 @@ declare const methods: {
     copyNodes: (this: MindElixirInstance, tpcs: import("./index").Topic[], to: import("./index").Topic) => Promise<void>;
     moveUpNode: (this: MindElixirInstance, el?: import("./index").Topic | undefined) => Promise<void>;
     moveDownNode: (this: MindElixirInstance, el?: import("./index").Topic | undefined) => Promise<void>;
-    removeNode: (this: MindElixirInstance, el?: import("./index").Topic | undefined) => Promise<void>;
     removeNodes: (this: MindElixirInstance, tpcs: import("./index").Topic[]) => Promise<void>;
     moveNodeIn: (this: MindElixirInstance, from: import("./index").Topic[], to: import("./index").Topic) => Promise<void>;
     moveNodeBefore: (this: MindElixirInstance, from: import("./index").Topic[], to: import("./index").Topic) => Promise<void>;
     moveNodeAfter: (this: MindElixirInstance, from: import("./index").Topic[], to: import("./index").Topic) => Promise<void>;
     beginEdit: (this: MindElixirInstance, el?: import("./index").Topic | undefined) => Promise<void>;
     setNodeTopic: (this: MindElixirInstance, el: import("./index").Topic, topic: string) => Promise<void>;
-    selectNode: (this: MindElixirInstance, targetElement: import("./index").Topic, isNewNode?: boolean | undefined, e?: MouseEvent | undefined) => void;
-    unselectNode: (this: MindElixirInstance) => void;
+    scrollIntoView: (this: MindElixirInstance, el: HTMLElement) => void;
+    selectNode: (this: MindElixirInstance, tpc: import("./index").Topic, isNewNode?: boolean, e?: MouseEvent) => void;
     selectNodes: (this: MindElixirInstance, tpc: import("./index").Topic[]) => void;
-    unselectNodes: (this: MindElixirInstance) => void;
+    unselectNodes: (this: MindElixirInstance, tpc: import("./index").Topic[]) => void;
     clearSelection: (this: MindElixirInstance) => void;
     getDataString: (this: MindElixirInstance) => string;
     getData: (this: MindElixirInstance) => MindElixirData;
@@ -69,14 +68,15 @@ declare const methods: {
     initRight: (this: MindElixirInstance) => void;
     initSide: (this: MindElixirInstance) => void;
     setLocale: (this: MindElixirInstance, locale: import("./i18n").Locale) => void;
-    expandNode: (this: MindElixirInstance, el: import("./index").Topic, isExpand?: boolean | undefined) => void;
-    refresh: (this: MindElixirInstance, data?: MindElixirData | undefined) => void;
+    expandNode: (this: MindElixirInstance, el: import("./index").Topic, isExpand?: boolean) => void;
+    expandNodeAll: (this: MindElixirInstance, el: import("./index").Topic, isExpand?: boolean) => void;
+    refresh: (this: MindElixirInstance, data?: MindElixirData) => void;
     getObjById: (id: string, data: import("./types").NodeObj) => import("./types").NodeObj | null;
     generateNewObj: (this: MindElixirInstance) => import("./types").NodeObjExport;
     layout: (this: MindElixirInstance) => void;
-    linkDiv: (this: MindElixirInstance, mainNode?: import("./index").Wrapper | undefined) => void;
+    linkDiv: (this: MindElixirInstance, mainNode?: import("./index").Wrapper) => void;
     editTopic: (this: MindElixirInstance, el: import("./index").Topic) => void;
-    createWrapper: (this: MindElixirInstance, nodeObj: import("./types").NodeObj, omitChildren?: boolean | undefined) => {
+    createWrapper: (this: MindElixirInstance, nodeObj: import("./types").NodeObj, omitChildren?: boolean) => {
         grp: import("./index").Wrapper;
         top: import("./index").Parent;
         tpc: import("./index").Topic;
@@ -87,7 +87,7 @@ declare const methods: {
     };
     createChildren: (this: MindElixirInstance, wrappers: import("./index").Wrapper[]) => import("./index").Children;
     createTopic: (this: MindElixirInstance, nodeObj: import("./types").NodeObj) => import("./index").Topic;
-    findEle: (id: string, instance?: MindElixirInstance | undefined) => import("./index").Topic;
+    findEle: (this: MindElixirInstance, id: string, el?: HTMLElement) => import("./index").Topic;
     changeTheme: (this: MindElixirInstance, theme: import("./types").Theme, shouldRefresh?: boolean) => void;
 };
 export default methods;

package/dist/types/mouse.d.ts

@@ -1,2 +1,2 @@
 import type { MindElixirInstance } from './types/index';
-export default function (mind: MindElixirInstance): void;
+export default function (mind: MindElixirInstance): () => void;

package/dist/types/nodeOperation.d.ts

@@ -2,14 +2,13 @@ import type { Topic } from './types/dom';
 import { type MindElixirInstance, type NodeObj } from './types/index';
 export declare const rmSubline: (tpc: Topic) => void;
 export declare const reshapeNode: (this: MindElixirInstance, tpc: Topic, patchData: Partial<NodeObj>) => void;
-export declare const insertSibling: (this: MindElixirInstance, type: 'before' | 'after', el?: Topic, node?: NodeObj) => void;
+export declare const insertSibling: (this: MindElixirInstance, type: "before" | "after", el?: Topic, node?: NodeObj) => void;
 export declare const insertParent: (this: MindElixirInstance, el?: Topic, node?: NodeObj) => void;
 export declare const addChild: (this: MindElixirInstance, el?: Topic, node?: NodeObj) => void;
 export declare const copyNode: (this: MindElixirInstance, node: Topic, to: Topic) => void;
 export declare const copyNodes: (this: MindElixirInstance, tpcs: Topic[], to: Topic) => void;
 export declare const moveUpNode: (this: MindElixirInstance, el?: Topic) => void;
 export declare const moveDownNode: (this: MindElixirInstance, el?: Topic) => void;
-export declare const removeNode: (this: MindElixirInstance, el?: Topic) => void;
 export declare const removeNodes: (this: MindElixirInstance, tpcs: Topic[]) => void;
 export declare const moveNodeIn: (this: MindElixirInstance, from: Topic[], to: Topic) => void;
 export declare const moveNodeBefore: (this: MindElixirInstance, from: Topic[], to: Topic) => void;

package/dist/types/plugin/contextMenu.d.ts

@@ -9,4 +9,4 @@ export type ContextMenuOption = {
         onclick: (e: MouseEvent) => void;
     }[];
 };
-export default function (mind: MindElixirInstance, option?: ContextMenuOption): () => void;
+export default function (mind: MindElixirInstance, option: true | ContextMenuOption): () => void;

package/dist/types/plugin/keypress.d.ts

@@ -1,2 +1,6 @@
-import type { MindElixirInstance } from '../types/index';
-export default function (mind: MindElixirInstance): void;
+import type { KeypressOptions, MindElixirInstance } from '../types/index';
+export declare const handleZoom: (mei: MindElixirInstance, direction: "in" | "out", offset?: {
+    x: number;
+    y: number;
+}) => void;
+export default function (mind: MindElixirInstance, options: boolean | KeypressOptions): void;

package/dist/types/plugin/nodeDraggable.d.ts

@@ -1,2 +1,2 @@
 import type { MindElixirInstance } from '../types/index';
-export default function (mind: MindElixirInstance): void;
+export default function (mind: MindElixirInstance): () => void;

package/dist/types/plugin/operationHistory.d.ts

@@ -1,2 +1,2 @@
 import { type MindElixirInstance } from '../index';
-export default function (mei: MindElixirInstance): void;
+export default function (mei: MindElixirInstance): () => void;

package/dist/types/summary.d.ts

@@ -23,7 +23,7 @@ export type SummarySvgGroup = SVGGElement & {
     summaryObj: Summary;
 };
 export declare const createSummary: (this: MindElixirInstance) => void;
-export declare const createSummaryFrom: (this: MindElixirInstance, summary: Omit<Summary, 'id'>) => void;
+export declare const createSummaryFrom: (this: MindElixirInstance, summary: Omit<Summary, "id">) => void;
 export declare const removeSummary: (this: MindElixirInstance, id: string) => void;
 export declare const selectSummary: (this: MindElixirInstance, el: SummarySvgGroup) => void;
 export declare const unselectSummary: (this: MindElixirInstance) => void;

package/dist/types/types/index.d.ts

@@ -4,11 +4,11 @@ import type { MindElixirMethods, OperationMap, Operations } from '../methods';
 import type { LinkDragMoveHelperInstance } from '../utils/LinkDragMoveHelper';
 import type { Arrow } from '../arrow';
 import type { Summary, SummarySvgGroup } from '../summary';
-import type SelectionArea from '@viselect/vanilla';
 import type { MainLineParams, SubLineParams } from '../utils/generateBranch';
 import type { Locale } from '../i18n';
 import type { ContextMenuOption } from '../plugin/contextMenu';
 import type { createDragMoveHelper } from '../utils/dragMoveHelper';
+import type SelectionArea from '@viselect/vanilla';
 export { type MindElixirMethods } from '../methods';
 export declare enum DirectionClass {
     LHS = "lhs",
@@ -32,8 +32,11 @@ export type Theme = {
      * Color palette for main branches
      */
     palette: string[];
-    cssVar: Partial<{
-        '--gap': string;
+    cssVar: {
+        '--node-gap-x': string;
+        '--node-gap-y': string;
+        '--main-gap-x': string;
+        '--main-gap-y': string;
         '--main-color': string;
         '--main-bgcolor': string;
         '--color': string;
@@ -48,46 +51,34 @@ export type Theme = {
         '--panel-color': string;
         '--panel-bgcolor': string;
         '--panel-border-color': string;
-    }>;
+        '--map-padding': string;
+    };
 };
 export type Alignment = 'root' | 'nodes';
+export interface KeypressOptions {
+    [key: string]: (e: KeyboardEvent) => void;
+}
 /**
  * The MindElixir instance
  *
  * @public
  */
-export interface MindElixirInstance extends MindElixirMethods {
+export interface MindElixirInstance extends Required<Options>, MindElixirMethods {
+    dragged: Topic[] | null;
+    el: HTMLElement;
     disposable: Array<() => void>;
     isFocusMode: boolean;
     nodeDataBackup: NodeObj;
-    mindElixirBox: HTMLElement;
     nodeData: NodeObj;
     arrows: Arrow[];
     summaries: Summary[];
-    currentNode: Topic | null;
-    currentNodes: Topic[] | null;
+    readonly currentNode: Topic | null;
+    currentNodes: Topic[];
     currentSummary: SummarySvgGroup | null;
     currentArrow: CustomSvg | null;
     waitCopy: Topic[] | null;
     scaleVal: number;
     tempDirection: number | null;
-    theme: Theme;
-    userTheme?: Theme;
-    direction: number;
-    locale: Locale;
-    draggable: boolean;
-    editable: boolean;
-    contextMenu: boolean;
-    contextMenuOption?: ContextMenuOption;
-    toolBar: boolean;
-    keypress: boolean;
-    mouseSelectionButton: 0 | 2;
-    before: Before;
-    newTopicName: string;
-    allowUndo: boolean;
-    overflowHidden: boolean;
-    generateMainBranch: (params: MainLineParams) => PathString;
-    generateSubBranch: (params: SubLineParams) => PathString;
     container: HTMLElement;
     map: HTMLElement;
     root: HTMLElement;
@@ -113,8 +104,6 @@ export interface MindElixirInstance extends MindElixirMethods {
     undo: () => void;
     redo: () => void;
     selection: SelectionArea;
-    selectionContainer?: string | HTMLElement;
-    alignment: Alignment;
     dragMoveHelper: ReturnType<typeof createDragMoveHelper>;
 }
 type PathString = string;
@@ -123,16 +112,15 @@ type PathString = string;
  *
  * @public
  */
-export type Options = {
+export interface Options {
     el: string | HTMLElement;
     direction?: number;
     locale?: Locale;
     draggable?: boolean;
     editable?: boolean;
-    contextMenu?: boolean;
-    contextMenuOption?: ContextMenuOption;
+    contextMenu?: boolean | ContextMenuOption;
     toolBar?: boolean;
-    keypress?: boolean;
+    keypress?: boolean | KeypressOptions;
     mouseSelectionButton?: 0 | 2;
     before?: Before;
     newTopicName?: string;
@@ -141,10 +129,10 @@ export type Options = {
     generateMainBranch?: (this: MindElixirInstance, params: MainLineParams) => PathString;
     generateSubBranch?: (this: MindElixirInstance, params: SubLineParams) => PathString;
     theme?: Theme;
-    nodeMenu?: boolean;
     selectionContainer?: string | HTMLElement;
     alignment?: Alignment;
-};
+    scaleSensitivity?: number;
+}
 export type Uid = string;
 export type Left = 0;
 export type Right = 1;
@@ -156,12 +144,16 @@ export type Right = 1;
 export interface NodeObj {
     topic: string;
     id: Uid;
-    style?: {
-        fontSize?: string;
-        color?: string;
-        background?: string;
-        fontWeight?: string;
-    };
+    style?: Partial<{
+        fontSize: string;
+        fontFamily: string;
+        color: string;
+        background: string;
+        fontWeight: string;
+        width: string;
+        border: string;
+        textDecoration: string;
+    }>;
     children?: NodeObj[];
     tags?: string[];
     icons?: string[];

package/dist/types/utils/LinkDragMoveHelper.d.ts

@@ -1,26 +1,30 @@
 declare const create: (dom: HTMLElement) => {
     dom: HTMLElement;
     moved: boolean;
-    mousedown: boolean;
-    handleMouseMove(e: MouseEvent): void;
-    handleMouseDown(e: MouseEvent): void;
-    handleClear(e: MouseEvent): void;
+    pointerdown: boolean;
+    lastX: number;
+    lastY: number;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerDown(e: PointerEvent): void;
+    handleClear(e: PointerEvent): void;
     cb: ((deltaX: number, deltaY: number) => void) | null;
     init(map: HTMLElement, cb: (deltaX: number, deltaY: number) => void): void;
-    destory(map: HTMLElement): void;
+    destroy: (() => void) | null;
     clear(): void;
 };
 declare const LinkDragMoveHelper: {
     create: (dom: HTMLElement) => {
         dom: HTMLElement;
         moved: boolean;
-        mousedown: boolean;
-        handleMouseMove(e: MouseEvent): void;
-        handleMouseDown(e: MouseEvent): void;
-        handleClear(e: MouseEvent): void;
+        pointerdown: boolean;
+        lastX: number;
+        lastY: number;
+        handlePointerMove(e: PointerEvent): void;
+        handlePointerDown(e: PointerEvent): void;
+        handleClear(e: PointerEvent): void;
         cb: ((deltaX: number, deltaY: number) => void) | null;
         init(map: HTMLElement, cb: (deltaX: number, deltaY: number) => void): void;
-        destory(map: HTMLElement): void;
+        destroy: (() => void) | null;
         clear(): void;
     };
 };

package/dist/types/utils/dom.d.ts

@@ -1,6 +1,6 @@
 import type { Topic, Wrapper, Parent, Children, Expander } from '../types/dom';
 import type { MindElixirInstance, NodeObj } from '../types/index';
-export declare const findEle: (id: string, instance?: MindElixirInstance) => Topic;
+export declare const findEle: (this: MindElixirInstance, id: string, el?: HTMLElement) => Topic;
 export declare const shapeTpc: (tpc: Topic, nodeObj: NodeObj) => void;
 export declare const createWrapper: (this: MindElixirInstance, nodeObj: NodeObj, omitChildren?: boolean) => {
     grp: Wrapper;

package/dist/types/utils/dragMoveHelper.d.ts

@@ -4,6 +4,6 @@ export declare function createDragMoveHelper(mei: MindElixirInstance): {
     y: number;
     moved: boolean;
     mousedown: boolean;
-    onMove(e: MouseEvent): void;
+    onMove(deltaX: number, deltaY: number): void;
     clear(): void;
 };

package/dist/types/utils/index.d.ts

@@ -32,3 +32,8 @@ export declare const getTranslate: (styleText: string) => {
     x: number;
     y: number;
 };
+export declare const on: (list: { [K in keyof GlobalEventHandlersEventMap]: {
+    dom: EventTarget;
+    evt: K;
+    func: (this: EventTarget, ev: GlobalEventHandlersEventMap[K]) => void;
+}; }[keyof GlobalEventHandlersEventMap][]) => () => void;

package/dist/types/utils/layout-ssr.d.ts

@@ -0,0 +1,90 @@
+import { LEFT, RIGHT } from '../const';
+import { type NodeObj } from '../types/index';
+/**
+ * Server-side compatible layout data structure
+ */
+export interface SSRLayoutNode {
+    id: string;
+    topic: string;
+    direction?: typeof LEFT | typeof RIGHT;
+    style?: {
+        fontSize?: string;
+        color?: string;
+        background?: string;
+        fontWeight?: string;
+    };
+    children?: SSRLayoutNode[];
+    tags?: string[];
+    icons?: string[];
+    hyperLink?: string;
+    expanded?: boolean;
+    image?: {
+        url: string;
+        width: number;
+        height: number;
+        fit?: 'fill' | 'contain' | 'cover';
+    };
+    branchColor?: string;
+    dangerouslySetInnerHTML?: string;
+    note?: string;
+}
+/**
+ * SSR Layout result structure
+ */
+export interface SSRLayoutResult {
+    root: SSRLayoutNode;
+    leftNodes: SSRLayoutNode[];
+    rightNodes: SSRLayoutNode[];
+    direction: number;
+}
+/**
+ * SSR Layout options
+ */
+export interface SSRLayoutOptions {
+    direction?: number;
+    newTopicName?: string;
+}
+/**
+ * Server-side compatible layout function for SSR
+ * This function processes the mind map data structure without DOM manipulation
+ *
+ * @param nodeData - The root node data
+ * @param options - Layout options including direction
+ * @returns Structured layout data for server-side rendering
+ */
+export declare const layoutSSR: (nodeData: NodeObj, options?: SSRLayoutOptions) => SSRLayoutResult;
+/**
+ * Generate HTML string for server-side rendering
+ * This function creates the HTML structure that would be generated by the DOM-based layout
+ *
+ * @param layoutResult - The result from layoutSSR function
+ * @param options - Additional rendering options
+ * @returns HTML string for server-side rendering
+ */
+export declare const renderSSRHTML: (layoutResult: SSRLayoutResult, options?: {
+    className?: string;
+}) => string;
+/**
+ * Generate JSON data structure for client-side hydration
+ * This can be used to pass the layout data to the client for hydration
+ *
+ * @param layoutResult - The result from layoutSSR function
+ * @returns JSON-serializable data structure
+ */
+export declare const getSSRData: (layoutResult: SSRLayoutResult) => string;
+/**
+ * Hydration data structure for client-side initialization
+ */
+export interface HydrationData {
+    nodeData: NodeObj;
+    layoutResult: SSRLayoutResult;
+    options: {
+        direction: number;
+        [key: string]: any;
+    };
+    timestamp: number;
+}
+/**
+ * Generate complete hydration data including original nodeData
+ */
+export declare const getHydrationData: (nodeData: NodeObj, layoutResult: SSRLayoutResult, options?: any) => HydrationData;