mind-elixir 4.1.3 → 4.1.5

package/dist/types/summary.d.ts

@@ -0,0 +1,18 @@
+import type { MindElixirInstance } from '.';
+export type Summary = {
+    id: string;
+    text: string;
+    parent: string;
+    start: number;
+    end: number;
+};
+export type SummarySvgGroup = SVGGElement & {
+    children: [SVGPathElement, SVGTextElement];
+    summaryObj: Summary;
+};
+export declare const createSummary: (this: MindElixirInstance) => 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;
+export declare const renderSummary: (this: MindElixirInstance) => void;
+export declare const editSummary: (this: MindElixirInstance, el: SummarySvgGroup) => void;

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

@@ -0,0 +1,50 @@
+import type { Arrow } from '../arrow';
+import type { NodeObj } from './index';
+export interface Wrapper extends HTMLElement {
+    firstChild: Parent;
+    children: HTMLCollection & [Parent, Children];
+    parentNode: Children;
+    parentElement: Children;
+    offsetParent: Wrapper;
+    previousSibling: Wrapper | null;
+    nextSibling: Wrapper | null;
+}
+export interface Parent extends HTMLElement {
+    firstChild: Topic;
+    children: HTMLCollection & [Topic, Expander | undefined];
+    parentNode: Wrapper;
+    parentElement: Wrapper;
+    nextSibling: Children;
+    offsetParent: Wrapper;
+}
+export interface Children extends HTMLElement {
+    parentNode: Wrapper;
+    children: HTMLCollection & Wrapper[];
+    parentElement: Wrapper;
+    firstChild: Wrapper;
+    previousSibling: Parent;
+}
+export interface Topic extends HTMLElement {
+    nodeObj: NodeObj;
+    parentNode: Parent;
+    parentElement: Parent;
+    offsetParent: Parent;
+    text: HTMLSpanElement;
+    expander?: Expander;
+    linkContainer?: HTMLElement;
+    image?: HTMLImageElement;
+    icons?: HTMLSpanElement;
+    tags?: HTMLDivElement;
+}
+export interface Expander extends HTMLElement {
+    expanded?: boolean;
+    parentNode: Parent;
+    parentElement: Parent;
+    previousSibling: Topic;
+}
+export type CustomLine = SVGPathElement;
+export type CustomArrow = SVGPathElement;
+export interface CustomSvg extends SVGGElement {
+    arrowObj: Arrow;
+    children: HTMLCollection & [CustomLine, CustomArrow, SVGTextElement];
+}

package/dist/types/types/global.d.ts

@@ -0,0 +1,7 @@
+export {};
+declare global {
+    interface Element {
+        setAttribute(name: string, value: boolean): void;
+        setAttribute(name: string, value: number): void;
+    }
+}

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

@@ -0,0 +1,169 @@
+import type Bus from '../utils/pubsub';
+import type { Topic, CustomSvg } from './dom';
+import type { EventMap, Operation } from '../utils/pubsub';
+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';
+export * from '../methods';
+type Before = Partial<{
+    [K in Operations]: (...args: Parameters<OperationMap[K]>) => Promise<boolean> | boolean;
+}>;
+export type Theme = {
+    name: string;
+    palette: string[];
+    cssVar: Partial<{
+        '--main-color': string;
+        '--main-bgcolor': string;
+        '--color': string;
+        '--bgcolor': string;
+        '--selected': string;
+        '--panel-color': string;
+        '--panel-bgcolor': string;
+        '--root-color': string;
+        '--root-bgcolor': string;
+        '--root-radius': string;
+        '--main-radius': string;
+        '--topic-padding': string;
+        '--panel-border-color': string;
+    }>;
+};
+/**
+ * The MindElixir instance
+ *
+ * @public
+ */
+export interface MindElixirInstance extends MindElixirMethods {
+    disposable: Array<() => void>;
+    isFocusMode: boolean;
+    nodeDataBackup: NodeObj;
+    mindElixirBox: HTMLElement;
+    nodeData: NodeObj;
+    arrows: Arrow[];
+    summaries: Summary[];
+    currentNode: Topic | null;
+    currentNodes: Topic[] | null;
+    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: object;
+    toolBar: boolean;
+    keypress: boolean;
+    mouseSelectionButton: 0 | 2;
+    before: Before;
+    newTopicName: string;
+    allowUndo: boolean;
+    overflowHidden: boolean;
+    mainBranchStyle: number;
+    subBranchStyle: number;
+    mobileMenu: boolean;
+    generateMainBranch: (params: MainLineParams) => PathString;
+    generateSubBranch: (params: SubLineParams) => PathString;
+    container: HTMLElement;
+    map: HTMLElement;
+    root: HTMLElement;
+    nodes: HTMLElement;
+    lines: SVGElement;
+    summarySvg: SVGElement;
+    linkController: SVGElement;
+    P2: HTMLElement;
+    P3: HTMLElement;
+    line1: SVGElement;
+    line2: SVGElement;
+    linkSvgGroup: SVGElement;
+    /**
+     * @internal
+     */
+    helper1?: LinkDragMoveHelperInstance;
+    /**
+     * @internal
+     */
+    helper2?: LinkDragMoveHelperInstance;
+    bus: ReturnType<typeof Bus.create<EventMap>>;
+    history: Operation[];
+    undo: () => void;
+    redo: () => void;
+    selection: SelectionArea;
+}
+type PathString = string;
+/**
+ * The MindElixir options
+ *
+ * @public
+ */
+export type Options = {
+    el: string | HTMLElement;
+    direction?: number;
+    locale?: Locale;
+    draggable?: boolean;
+    editable?: boolean;
+    contextMenu?: boolean;
+    contextMenuOption?: any;
+    toolBar?: boolean;
+    keypress?: boolean;
+    mouseSelectionButton?: 0 | 2;
+    before?: Before;
+    newTopicName?: string;
+    allowUndo?: boolean;
+    overflowHidden?: boolean;
+    generateMainBranch?: (this: MindElixirInstance, params: MainLineParams) => PathString;
+    generateSubBranch?: (this: MindElixirInstance, params: SubLineParams) => PathString;
+    mobileMenu?: boolean;
+    theme?: Theme;
+    nodeMenu?: boolean;
+};
+export type Uid = string;
+/**
+ * MindElixir node object
+ *
+ * @public
+ */
+export type NodeObj = {
+    topic: string;
+    id: Uid;
+    style?: {
+        fontSize?: string;
+        color?: string;
+        background?: string;
+        fontWeight?: string;
+    };
+    children?: NodeObj[];
+    tags?: string[];
+    icons?: string[];
+    hyperLink?: string;
+    expanded?: boolean;
+    direction?: number;
+    image?: {
+        url: string;
+        width: number;
+        height: number;
+    };
+    branchColor?: string;
+    parent?: NodeObj;
+    dangerouslySetInnerHTML?: string;
+};
+export type NodeObjExport = Omit<NodeObj, 'parent'>;
+/**
+ * The exported data of MindElixir
+ *
+ * @public
+ */
+export type MindElixirData = {
+    nodeData: NodeObj;
+    arrows?: Arrow[];
+    summaries?: Summary[];
+    direction?: number;
+    theme?: Theme;
+};

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

@@ -0,0 +1,28 @@
+declare const create: (dom: HTMLElement) => {
+    dom: HTMLElement;
+    moved: boolean;
+    mousedown: boolean;
+    handleMouseMove(e: MouseEvent): void;
+    handleMouseDown(e: MouseEvent): void;
+    handleClear(e: MouseEvent): void;
+    cb: ((deltaX: number, deltaY: number) => void) | null;
+    init(map: HTMLElement, cb: (deltaX: number, deltaY: number) => void): void;
+    destory(map: HTMLElement): void;
+    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;
+        cb: ((deltaX: number, deltaY: number) => void) | null;
+        init(map: HTMLElement, cb: (deltaX: number, deltaY: number) => void): void;
+        destory(map: HTMLElement): void;
+        clear(): void;
+    };
+};
+export type LinkDragMoveHelperInstance = ReturnType<typeof create>;
+export default LinkDragMoveHelper;

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

@@ -0,0 +1,18 @@
+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 shapeTpc: (tpc: Topic, nodeObj: NodeObj) => void;
+export declare const createWrapper: (this: MindElixirInstance, nodeObj: NodeObj, omitChildren?: boolean) => {
+    grp: Wrapper;
+    top: Parent;
+    tpc: Topic;
+};
+export declare const createParent: (this: MindElixirInstance, nodeObj: NodeObj) => {
+    p: Parent;
+    tpc: Topic;
+};
+export declare const createChildren: (this: MindElixirInstance, wrappers: Wrapper[]) => Children;
+export declare const createTopic: (this: MindElixirInstance, nodeObj: NodeObj) => Topic;
+export declare function selectText(div: HTMLElement): void;
+export declare const editTopic: (this: MindElixirInstance, el: Topic) => void;
+export declare const createExpander: (expanded: boolean | undefined) => Expander;

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

@@ -0,0 +1,5 @@
+import type { MindElixirInstance, NodeObj } from '../types';
+import type { Topic, Wrapper } from '../types/dom';
+export declare const judgeDirection: (direction: number, obj: NodeObj) => 0 | 1 | undefined;
+export declare const addChildDom: (mei: MindElixirInstance, to: Topic, wrapper: Wrapper) => void;
+export declare const removeNodeDom: (tpc: Topic, siblingLength: number) => void;

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

@@ -0,0 +1,7 @@
+declare const _default: {
+    moved: boolean;
+    mousedown: boolean;
+    onMove(e: MouseEvent, container: HTMLElement): void;
+    clear(): void;
+};
+export default _default;

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

@@ -0,0 +1,27 @@
+import type { MindElixirInstance } from '..';
+export type MainLineParams = {
+    pT: number;
+    pL: number;
+    pW: number;
+    pH: number;
+    cT: number;
+    cL: number;
+    cW: number;
+    cH: number;
+    direction: 'lhs' | 'rhs';
+    containerHeight: number;
+};
+export type SubLineParams = {
+    pT: number;
+    pL: number;
+    pW: number;
+    pH: number;
+    cT: number;
+    cL: number;
+    cW: number;
+    cH: number;
+    direction: 'lhs' | 'rhs';
+    isFirst: boolean | undefined;
+};
+export declare function main({ pT, pL, pW, pH, cT, cL, cW, cH, direction, containerHeight }: MainLineParams): string;
+export declare function sub(this: MindElixirInstance, { pT, pL, pW, pH, cT, cL, cW, cH, direction, isFirst }: SubLineParams): string;

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

@@ -0,0 +1,30 @@
+import type { Topic } from '../types/dom';
+import type { NodeObj, MindElixirInstance, NodeObjExport } from '../types/index';
+export declare function encodeHTML(s: string): string;
+export declare const isMobile: () => boolean;
+export declare const getObjById: (id: string, data: NodeObj) => NodeObj | null;
+/**
+ * Add parent property to every node
+ */
+export declare const fillParent: (data: NodeObj, parent?: NodeObj) => void;
+export declare function refreshIds(data: NodeObj): void;
+export declare const throttle: <T extends (...args: never[]) => void>(fn: T, wait: number) => (...args: Parameters<T>) => void;
+export declare function getArrowPoints(p3x: number, p3y: number, p4x: number, p4y: number): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export declare function generateUUID(): string;
+export declare const generateNewObj: (this: MindElixirInstance) => NodeObjExport;
+export declare function checkMoveValid(from: NodeObj, to: NodeObj): boolean;
+export declare function deepClone(obj: NodeObj): any;
+export declare const getOffsetLT: (parent: HTMLElement, child: HTMLElement) => {
+    offsetLeft: number;
+    offsetTop: number;
+};
+export declare const setAttributes: (el: HTMLElement | SVGElement, attrs: {
+    [key: string]: string;
+}) => void;
+export declare const isTopic: (target?: HTMLElement) => target is Topic;
+export declare const unionTopics: (nodes: Topic[]) => Topic[];

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

@@ -0,0 +1,4 @@
+import type { Children } from '../types/dom';
+import type { MindElixirInstance, NodeObj } from '../types/index';
+export declare const layout: (this: MindElixirInstance) => void;
+export declare const layoutChildren: (mei: MindElixirInstance, data: NodeObj[]) => Children;

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

@@ -0,0 +1,7 @@
+import type { NodeObj } from '../types';
+export declare function moveUpObj(obj: NodeObj): void;
+export declare function moveDownObj(obj: NodeObj): void;
+export declare function removeNodeObj(obj: NodeObj): number;
+export declare function insertNodeObj(newObj: NodeObj, type: 'before' | 'after', obj: NodeObj): void;
+export declare function insertParentNodeObj(obj: NodeObj, newObj: NodeObj): void;
+export declare function moveNodeObj(type: 'in' | 'before' | 'after', from: NodeObj, to: NodeObj): void;

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

@@ -0,0 +1,80 @@
+import type { Arrow } from '../arrow';
+import type { Summary } from '../summary';
+import type { NodeObj } from '../types/index';
+type NodeOperation = {
+    name: 'moveNodeIn' | 'moveDownNode' | 'moveUpNode' | 'copyNode' | 'addChild' | 'insertParent' | 'insertBefore' | 'beginEdit';
+    obj: NodeObj;
+} | {
+    name: 'insertSibling';
+    type: 'before' | 'after';
+    obj: NodeObj;
+} | {
+    name: 'reshapeNode';
+    obj: NodeObj;
+    origin: NodeObj;
+} | {
+    name: 'finishEdit';
+    obj: NodeObj;
+    origin: string;
+} | {
+    name: 'moveNodeAfter' | 'moveNodeBefore' | 'moveNodeIn';
+    objs: NodeObj[];
+    toObj: NodeObj;
+} | {
+    name: 'removeNode';
+    obj: NodeObj;
+    originIndex?: number;
+    originParentId?: string;
+};
+type MultipleNodeOperation = {
+    name: 'removeNodes';
+    objs: NodeObj[];
+} | {
+    name: 'copyNodes';
+    objs: NodeObj[];
+};
+export type SummaryOperation = {
+    name: 'createSummary';
+    obj: Summary;
+} | {
+    name: 'removeSummary';
+    obj: {
+        id: string;
+    };
+} | {
+    name: 'finishEditSummary';
+    obj: Summary;
+};
+export type ArrowOperation = {
+    name: 'createArrow';
+    obj: Arrow;
+} | {
+    name: 'removeArrow';
+    obj: {
+        id: string;
+    };
+} | {
+    name: 'finishEditArrowLabel';
+    obj: Arrow;
+};
+export type Operation = NodeOperation | MultipleNodeOperation | SummaryOperation | ArrowOperation;
+export type OperationType = Operation['name'];
+export type EventMap = {
+    operation: (info: Operation) => void;
+    selectNode: (nodeObj: NodeObj, e?: MouseEvent) => void;
+    selectNewNode: (nodeObj: NodeObj) => void;
+    selectNodes: (nodeObj: NodeObj[]) => void;
+    unselectNode: () => void;
+    unselectNodes: () => void;
+    expandNode: (nodeObj: NodeObj) => void;
+};
+declare const Bus: {
+    create<T extends Record<string, (...args: any[]) => void> = EventMap>(): {
+        handlers: Record<keyof T, ((...arg: any[]) => void)[]>;
+        showHandler: () => void;
+        addListener: <K extends keyof T>(type: K, handler: T[K]) => void;
+        fire: <K extends keyof T>(type: K, ...payload: Parameters<T[K]>) => void;
+        removeListener: <K extends keyof T>(type: K, handler: T[K]) => void;
+    };
+};
+export default Bus;

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

@@ -0,0 +1,7 @@
+import type { MindElixirInstance } from '../types';
+import type { CustomSvg } from '../types/dom';
+export declare const createPath: (d: string, color: string, width: string) => SVGPathElement;
+export declare const createLinkSvg: (klass: string) => SVGSVGElement;
+export declare const createLine: () => SVGLineElement;
+export declare const createSvgGroup: (d: string, arrowd: string) => CustomSvg;
+export declare const editSvgText: (mei: MindElixirInstance, textEl: SVGTextElement, onblur: (div: HTMLDivElement) => void) => void;

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

@@ -0,0 +1,4 @@
+import type { MindElixirInstance } from '../types/index';
+import type { Theme } from '../types/index';
+declare const changeTheme: (this: MindElixirInstance, theme: Theme, shouldRefresh?: boolean) => void;
+export default changeTheme;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mind-elixir",
-  "version": "4.1.3",
+  "version": "4.1.5",
   "type": "module",
   "description": "Mind elixir is a free open source mind map core.",
   "keywords": [
@@ -13,7 +13,7 @@
     "prepare": "husky install",
     "lint": "eslint --cache --max-warnings 0  \"src/**/*.{js,json,ts}\" --fix",
     "dev": "vite",
-    "build": "tsc && node build.js",
+    "build": "node build.js && tsc",
     "tsc": "tsc",
     "preview": "vite preview",
     "test": "playwright test",