@umbraci/jsmind 0.10.14 → 0.10.17

package/types/generated/plugins/history/jsmind.history.d.ts

@@ -0,0 +1,87 @@
+export default HistoryPlugin;
+export type JsMind = import("../../jsmind.js").default;
+export type DiffResult = import("./history-diff.js").DiffResult;
+export type DiffOptions = import("./history-diff.js").DiffOptions;
+/**
+ * HistoryPlugin skeleton (Task 1)
+ */
+export class HistoryPlugin extends EnhancedPlugin {
+    /**
+     * @param {{ jm: JsMind, pluginOpt?: any }} params
+     */
+    constructor({ jm, pluginOpt }: {
+        jm: JsMind;
+        pluginOpt?: any;
+    });
+    options: any;
+    _mounted: boolean;
+    _core: HistoryCore;
+    /**
+     * Lifecycle hook: called when jsMind instance is destroyed
+     */
+    beforePluginDestroy(): void;
+    /** Default: call beforePluginRemove on destroy */
+    beforePluginDestroy(): void;
+    /** Initialize HistoryCore and wire API methods */
+    _initCore(): void;
+    _listener: (type: any, payload: any) => void;
+    /**
+     * Inject shortcut options so provider can register mapping in its init phase
+     * @param {{ enable?: boolean, handles: Record<string,Function>, mapping: Record<string, number|number[]> }} sc
+     * @param {boolean} redoUsesY
+     */
+    _injectShortcuts(sc: {
+        enable?: boolean;
+        handles: Record<string, Function>;
+        mapping: Record<string, number | number[]>;
+    }, redoUsesY: boolean): void;
+    /** Mount public API on jm.history (placeholder defaults) */
+    _mountAPI(): void;
+}
+import { EnhancedPlugin } from '../../jsmind.enhanced-plugin.js';
+declare class HistoryCore {
+    /** @param {JsMind} jm @param {any} options */
+    constructor(jm: JsMind, options: any);
+    jm: import("../../jsmind.js").default;
+    options: any;
+    enabled: boolean;
+    maxHistory: number;
+    throttleMs: number;
+    storageMode: any;
+    autoSwitchThreshold: number;
+    _history: any[];
+    _idx: number;
+    _paused: boolean;
+    _lastAddAt: number;
+    _timer: number;
+    _pending: boolean;
+    _pendingMeta: any;
+    _lastSig: any;
+    _lastRootId: any;
+    add(reason: string, meta: any): void;
+    pause(): void;
+    resume(flush?: boolean): void;
+    clear(): void;
+    canBack(): boolean;
+    canForward(): boolean;
+    back(steps?: number): boolean;
+    forward(steps?: number): boolean;
+    length(): number;
+    index(): number;
+    setMax(count: any): void;
+    setThrottle(ms: any): void;
+    exportSnapshot(): any;
+    importSnapshot(data: any, applyOptions: any): boolean;
+    getStackMeta(): {
+        items: any[];
+        index: number;
+    };
+    _notifyChange(): void;
+    _addNow(_reason: any, _meta: any): void;
+    _applyIndex(): boolean;
+    _takeSnapshot(): any;
+    _applySnapshot(data: any, applyOptions: any): boolean;
+    _countNodes(snapshot: any): number;
+    _deepFreeze(obj: any): any;
+    _cloneSnapshot(obj: any): any;
+}

package/types/generated/plugins/jsmind.draggable-node.d.ts

@@ -0,0 +1,262 @@
+/**
+ * Draggable node plugin for jsMind.
+ */
+export class DraggableNode {
+    /**
+     * Create draggable node plugin instance.
+     * @param {import('../jsmind.js').default} jm - jsMind instance
+     * @param {Partial<DraggableNodeOptions>} options - Plugin options
+     */
+    constructor(jm: import("../jsmind.js").default, options: Partial<DraggableNodeOptions>);
+    version: string;
+    /** @type {import('../jsmind.js').default} */
+    jm: import("../jsmind.js").default;
+    /** @type {DraggableNodeOptions} */
+    options: DraggableNodeOptions;
+    /** @type {boolean} */
+    is_svg_engine: boolean;
+    /** @type {HTMLCanvasElement|SVGSVGElement|null} */
+    e_canvas: HTMLCanvasElement | SVGSVGElement | null;
+    /** @type {CanvasRenderingContext2D|null} */
+    canvas_ctx: CanvasRenderingContext2D | null;
+    /** @type {SVGPathElement|null} */
+    helper_line: SVGPathElement | null;
+    /** @type {HTMLElement|null} */
+    shadow: HTMLElement | null;
+    /** @type {number} */
+    shadow_p_x: number;
+    /** @type {number} */
+    shadow_p_y: number;
+    /** @type {number} */
+    shadow_w: number;
+    /** @type {number} */
+    shadow_h: number;
+    /** @type {import('../jsmind.node.js').Node|null} */
+    active_node: import("../jsmind.node.js").Node | null;
+    /** @type {import('../jsmind.node.js').Node|null} */
+    target_node: import("../jsmind.node.js").Node | null;
+    /** @type {number|null} */
+    target_direct: number | null;
+    /** @type {number} */
+    client_w: number;
+    /** @type {number} */
+    client_h: number;
+    /** @type {number} */
+    offset_x: number;
+    /** @type {number} */
+    offset_y: number;
+    /** @type {number} */
+    hlookup_delay: number;
+    /** @type {number} */
+    hlookup_timer: number;
+    /** @type {boolean} */
+    capture: boolean;
+    /** @type {boolean} */
+    moved: boolean;
+    /** @type {boolean} */
+    canvas_draggable: boolean;
+    /** @type {HTMLElement} */
+    view_panel: HTMLElement;
+    /** @type {DOMRect|null} */
+    view_panel_rect: DOMRect | null;
+    /** Initialize the draggable node plugin. */
+    init(): void;
+    /** Resize canvas/SVG and shadow elements. */
+    resize(): void;
+    /** Create canvas or SVG for drawing drag lines. */
+    create_canvas(): void;
+    /**
+     * Create SVG element with proper namespace.
+     * @param {string} tag - SVG tag name
+     * @returns {SVGElement}
+     * @private
+     */
+    private _create_svg_element;
+    create_shadow(): void;
+    /**
+     * Reset shadow element style and cache its size.
+     * @param {HTMLElement} el - The node element to mirror as shadow
+     */
+    reset_shadow(el: HTMLElement): void;
+    /** Show the shadow element. */
+    show_shadow(): void;
+    /** Hide the shadow element. */
+    hide_shadow(): void;
+    /**
+     * Draw a helper line between the shadow and target node.
+     * @param {{x:number,y:number}} shadow_p - Shadow anchor point
+     * @param {{x:number,y:number}} node_p - Target node anchor point
+     * @param {boolean} invalid - Whether current target is invalid
+     */
+    magnet_shadow(shadow_p: {
+        x: number;
+        y: number;
+    }, node_p: {
+        x: number;
+        y: number;
+    }, invalid: boolean): void;
+    /** Clear helper lines from canvas or SVG. */
+    clear_lines(): void;
+    /**
+     * Draw a straight helper line on canvas.
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    canvas_lineto(x1: number, y1: number, x2: number, y2: number): void;
+    /**
+     * Draw a helper line on SVG using bezier curve.
+     * Reuses the line drawing logic from SvgGraph.
+     * @param {number} x1 - Start x coordinate
+     * @param {number} y1 - Start y coordinate
+     * @param {number} x2 - End x coordinate
+     * @param {number} y2 - End y coordinate
+     * @param {string} color - Line color
+     */
+    svg_draw_line(x1: number, y1: number, x2: number, y2: number, color: string): void;
+    /**
+     * Draw bezier curve to SVG path element.
+     * Reuses logic from SvgGraph._bezier_to.
+     * @param {SVGPathElement} path - SVG path element
+     * @param {number} x1 - Start x coordinate
+     * @param {number} y1 - Start y coordinate
+     * @param {number} x2 - End x coordinate
+     * @param {number} y2 - End y coordinate
+     * @private
+     */
+    private _svg_bezier_to;
+    /** Bind mouse/touch events for dragging. */
+    event_bind(): void;
+    /**
+     * Begin dragging interaction.
+     * @param {MouseEvent|TouchEvent} e - Pointer down event
+     */
+    dragstart(e: MouseEvent | TouchEvent): void;
+    view_draggable: boolean;
+    client_hw: number;
+    client_hh: number;
+    /**
+     * Drag handler to move shadow and auto-scroll container.
+     * @param {MouseEvent|TouchEvent} e - Pointer move event
+     */
+    drag(e: MouseEvent | TouchEvent): void;
+    /**
+     * Finish dragging, move the node if applicable.
+     * @param {MouseEvent|TouchEvent} e - Pointer up event
+     */
+    dragend(e: MouseEvent | TouchEvent): void;
+    /**
+     * Find the closest node element from an event target.
+     * @param {HTMLElement} el - Current DOM element
+     * @returns {HTMLElement|null} Matched node element or null
+     */
+    find_node_element(el: HTMLElement): HTMLElement | null;
+    /** Recompute target node under the shadow and draw helper. */
+    lookup_target_node(): void;
+    /**
+     * Get X coordinate of root node center.
+     * @returns {number}
+     */
+    get_root_x(): number;
+    /**
+     * Lookup overlapping node's parent near the shadow position.
+     * @param {number} direction - Direction constant
+     * @returns {import('../jsmind.node.js').Node|null}
+     */
+    lookup_overlapping_node_parent(direction: number): import("../jsmind.node.js").Node | null;
+    /**
+     * Find node's parent by a screen location.
+     * @param {number} x - Client X
+     * @param {number} y - Client Y
+     * @returns {import('../jsmind.node.js').Node|null}
+     */
+    lookup_node_parent_by_location(x: number, y: number): import("../jsmind.node.js").Node | null;
+    /**
+     * Lookup the closest node along a direction.
+     * @param {number} direction
+     * @returns {import('../jsmind.node.js').Node}
+     */
+    lookup_close_node(direction: number): import("../jsmind.node.js").Node;
+    /**
+     * Check if shadow is on the target side of a node.
+     * @param {import('../jsmind.node.js').Node} node
+     * @param {number} dir
+     * @returns {boolean}
+     */
+    shadow_on_target_side(node: import("../jsmind.node.js").Node, dir: number): boolean;
+    /**
+     * Distance from shadow to the right side of a node.
+     * @param {import('../jsmind.node.js').Node} node
+     * @returns {number}
+     */
+    shadow_to_right_of_node(node: import("../jsmind.node.js").Node): number;
+    /**
+     * Distance from shadow to the left side of a node.
+     * @param {import('../jsmind.node.js').Node} node
+     * @returns {number}
+     */
+    shadow_to_left_of_node(node: import("../jsmind.node.js").Node): number;
+    /**
+     * Vertical distance between shadow centerline and node centerline.
+     * @param {import('../jsmind.node.js').Node} node
+     * @returns {number}
+     */
+    shadow_to_base_line_of_node(node: import("../jsmind.node.js").Node): number;
+    /**
+     * Manhattan distance to a node along a direction.
+     * @param {import('../jsmind.node.js').Node} node
+     * @param {number} dir
+     * @returns {number}
+     */
+    shadow_to_node(node: import("../jsmind.node.js").Node, dir: number): number;
+    /**
+     * Calculate connection points of a node and the shadow.
+     * @param {import('../jsmind.node.js').Node} node
+     * @param {number} dir
+     * @returns {{sp:{x:number,y:number}, np:{x:number,y:number}}}
+     */
+    calc_point_of_node(node: import("../jsmind.node.js").Node, dir: number): {
+        sp: {
+            x: number;
+            y: number;
+        };
+        np: {
+            x: number;
+            y: number;
+        };
+    };
+    /**
+     * Move a node to a new parent/position.
+     * @param {import('../jsmind.node.js').Node} src_node
+     * @param {import('../jsmind.node.js').Node|null} target_node
+     * @param {number|null} target_direct
+     */
+    move_node(src_node: import("../jsmind.node.js").Node, target_node: import("../jsmind.node.js").Node | null, target_direct: number | null): void;
+    /**
+     * Handle jsMind events.
+     * @param {number|string} type - Event type
+     * @param {object} [data] - Event data
+     */
+    jm_event_handle(type: number | string, data?: object): void;
+}
+/**
+ * Draggable node plugin registration.
+ * @type {import('../jsmind.plugin.js').Plugin<Partial<DraggableNodeOptions>>}
+ */
+export const draggable_plugin: import("../jsmind.plugin.js").Plugin<Partial<DraggableNodeOptions>>;
+export default DraggableNode;
+/**
+ * Default options for draggable node plugin.
+ */
+export type DraggableNodeOptions = {
+    line_width?: number;
+    line_color?: string;
+    line_color_invalid?: string;
+    lookup_delay?: number;
+    lookup_interval?: number;
+    scrolling_trigger_width?: number;
+    scrolling_step_length?: number;
+    shadow_node_class_name?: string;
+    validate_drag?: (draggedNode: import("../jsmind.node.js").Node, targetNode: import("../jsmind.node.js").Node | null) => boolean;
+};

package/types/generated/plugins/jsmind.multi-select.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Multi-Select Plugin - Enhanced plugin for jsMind
+ */
+export class MultiSelectPlugin extends EnhancedPlugin {
+    /**
+     * @param {{ jm: import('../jsmind.js').default, pluginOpt: object }} params
+     */
+    constructor({ jm, pluginOpt }: {
+        jm: import("../jsmind.js").default;
+        pluginOpt: object;
+    });
+    options: any;
+    _mounted: boolean;
+    _core: MultiSelectCore;
+    _listener: (type: any, data: any) => void;
+    _enabled: boolean;
+    /**
+     * Initialize core and mount API
+     */
+    _initCore(): void;
+    _original_select_node: any;
+    _original_select_clear: any;
+    _domClickHandler: (e: any) => void;
+    /**
+     * Mount API to jsMind instance
+     */
+    _mountAPI(): void;
+    setEnabled(flag: any): void;
+    setOptions(partial: any): void;
+}
+export default MultiSelectPlugin;
+/**
+ * Default options for multi-select plugin.
+ */
+export type MultiSelectOptions = {
+    /**
+     * - Enable multi-select feature
+     */
+    enable_multi_select?: boolean;
+    /**
+     * - Include descendants in subtree selection
+     */
+    include_descendants?: boolean;
+    /**
+     * - Shift mode: false=simple subtree, true=advanced range
+     */
+    shift_simple_mode?: boolean;
+    /**
+     * - Node filter function
+     */
+    filter?: ((node: import("../jsmind.node.js").Node) => boolean) | null;
+};
+import { EnhancedPlugin } from '../jsmind.enhanced-plugin.js';
+/**
+ * Multi-Select Core - Handles all multi-select logic
+ */
+export class MultiSelectCore {
+    /**
+     * @param {import('../jsmind.js').default} jm - jsMind instance
+     * @param {MultiSelectOptions} options - Plugin options
+     */
+    constructor(jm: import("../jsmind.js").default, options: MultiSelectOptions);
+    jm: import("../jsmind.js").default;
+    options: MultiSelectOptions;
+    _selection_mode: string;
+    _last_selected_node: import("../jsmind.node.js").Node;
+    /**
+     * Ensure selection state is initialized
+     * @private
+     */
+    private _ensure_selection_state;
+    /**
+     * Get all selected nodes
+     * @returns {string[]} Array of selected node IDs
+     */
+    get_selected_nodes(): string[];
+    /**
+     * Check if a node is selected
+     * @param {string|import('../jsmind.node.js').Node} node - Node ID or Node instance
+     * @returns {boolean}
+     */
+    is_node_selected(node: string | import("../jsmind.node.js").Node): boolean;
+    /**
+     * Select a single node (clears other selections)
+     * @param {string|import('../jsmind.node.js').Node} node - Node ID or Node instance
+     */
+    select_node(node: string | import("../jsmind.node.js").Node): void;
+    /**
+     * Clear all selections
+     */
+    select_clear(): void;
+    /**
+     * Toggle node selection (equivalent to Ctrl/Cmd+Click)
+     * @param {string|import('../jsmind.node.js').Node} node - Node ID or Node instance
+     */
+    toggle_node_selection(node: string | import("../jsmind.node.js").Node): void;
+    /**
+     * Toggle subtree selection
+     * @param {string|import('../jsmind.node.js').Node} node - Node ID or Node instance
+     */
+    toggle_subtree_selection(node: string | import("../jsmind.node.js").Node, opts: any): void;
+    /**
+     * Get current selection mode
+     * @returns {'single'|'multi'|null}
+     */
+    get_selection_mode(): "single" | "multi" | null;
+    /**
+     * Handle node click event
+     * @param {Object} payload - Click event payload
+     * @param {MouseEvent} payload.e - Mouse event
+     * @param {string} payload.node - Node ID
+     * @param {HTMLElement} payload.element - Node element
+     * @param {string} payload.evt - Event type
+     */
+    _handle_node_click(payload: {
+        e: MouseEvent;
+        node: string;
+        element: HTMLElement;
+        evt: string;
+    }): void;
+    /**
+     * Handle node removed event
+     * @param {import('../jsmind.node.js').Node} node - Removed node
+     */
+    _handle_node_removed(node: import("../jsmind.node.js").Node): void;
+    /**
+     * Get multi-select mode from event
+     * @param {MouseEvent} e - Mouse event
+     * @returns {'ctrl'|'shift'|null}
+     */
+    _get_multi_select_mode(e: MouseEvent): "ctrl" | "shift" | null;
+    /**
+     * Append nodes to selection
+     * @param {import('../jsmind.node.js').Node[]} nodes - Nodes to select
+     * @param {Object} [options] - Options
+     * @param {import('../jsmind.node.js').Node} [options.focusNode] - Focus node
+     * @returns {import('../jsmind.node.js').Node[]} Actually added nodes
+     */
+    _append_selection(nodes: import("../jsmind.node.js").Node[], options?: {
+        focusNode?: import("../jsmind.node.js").Node;
+    }): import("../jsmind.node.js").Node[];
+    /**
+     * Remove nodes from selection
+     * @param {import('../jsmind.node.js').Node[]} nodes - Nodes to deselect
+     * @returns {import('../jsmind.node.js').Node[]} Actually removed nodes
+     */
+    _remove_selection(nodes: import("../jsmind.node.js").Node[]): import("../jsmind.node.js").Node[];
+    /**
+     * Deselect subtree
+     * @param {import('../jsmind.node.js').Node} node - Root node of subtree
+     */
+    _deselect_subtree(node: import("../jsmind.node.js").Node): void;
+    /**
+     * Clear selection state
+     * @returns {import('../jsmind.node.js').Node[]} Removed nodes
+     */
+    _clear_selection_state(): import("../jsmind.node.js").Node[];
+    /**
+     * Collect subtree nodes
+     * @param {import('../jsmind.node.js').Node} node - Root node
+     * @param {Object} options - Options
+     * @param {boolean} [options.includeChildren=true] - Include children
+     * @param {boolean} [options.respectFilter=false] - Respect filter
+     * @param {boolean} [options.skipRootFilter=false] - Skip root filter
+     * @returns {import('../jsmind.node.js').Node[]}
+     */
+    _collect_subtree_nodes(node: import("../jsmind.node.js").Node, options: {
+        includeChildren?: boolean;
+        respectFilter?: boolean;
+        skipRootFilter?: boolean;
+    }): import("../jsmind.node.js").Node[];
+    /**
+     * Ensure ancestor selection
+     * @param {import('../jsmind.node.js').Node[]} nodes - Nodes
+     * @param {import('../jsmind.node.js').Node} focusNode - Focus node
+     * @param {Object} options - Options
+     * @returns {import('../jsmind.node.js').Node[]}
+     */
+    _ensure_ancestor_selection(nodes: import("../jsmind.node.js").Node[], focusNode: import("../jsmind.node.js").Node, options: any): import("../jsmind.node.js").Node[];
+    /**
+     * Get selection filter
+     * @returns {Function|null}
+     */
+    _get_selection_filter(): Function | null;
+    /**
+     * Range select nodes (advanced mode)
+     * @param {string} nodeId - Target node ID
+     */
+    _range_select_nodes(nodeId: string): void;
+    /**
+     * Find nodes between two nodes
+     * @param {import('../jsmind.node.js').Node} from - Start node
+     * @param {import('../jsmind.node.js').Node} to - End node
+     * @returns {import('../jsmind.node.js').Node[]}
+     */
+    _find_nodes_between(from: import("../jsmind.node.js").Node, to: import("../jsmind.node.js").Node): import("../jsmind.node.js").Node[];
+    /**
+     * Derive selection mode from current state
+     * @returns {'single'|'multi'|null}
+     */
+    _derive_selection_mode(): "single" | "multi" | null;
+    /**
+     * Mark nodes as selected in view
+     * @param {import('../jsmind.node.js').Node[]} nodes - Nodes to mark
+     * @param {import('../jsmind.node.js').Node} focusNode - Focus node
+     */
+    _mark_nodes_selected(nodes: import("../jsmind.node.js").Node[], focusNode: import("../jsmind.node.js").Node): void;
+    /**
+     * Mark a node as selected in view
+     * @param {import('../jsmind.node.js').Node} node - Node to mark
+     */
+    _mark_node_selected(node: import("../jsmind.node.js").Node): void;
+    /**
+     * Unmark nodes as selected in view
+     * @param {import('../jsmind.node.js').Node[]} nodes - Nodes to unmark
+     */
+    _unmark_nodes_selected(nodes: import("../jsmind.node.js").Node[]): void;
+    /**
+     * Unmark a node as selected in view
+     * @param {import('../jsmind.node.js').Node} node - Node to unmark
+     */
+    _unmark_node_selected(node: import("../jsmind.node.js").Node): void;
+    /**
+     * Clear all selected nodes view
+     */
+    _clear_all_selected_nodes_view(): void;
+    /**
+     * Invoke select event
+     * @param {Object} data - Event data
+     */
+    _invoke_select_event(data: any): void;
+    /**
+     * Resolve node from ID or Node instance
+     * @param {string|import('../jsmind.node.js').Node} node - Node ID or Node instance
+     * @returns {import('../jsmind.node.js').Node|null}
+     */
+    _resolve_node(node: string | import("../jsmind.node.js").Node): import("../jsmind.node.js").Node | null;
+}

package/types/generated/plugins/jsmind.multiline-text-v2.d.ts

@@ -0,0 +1,58 @@
+export default MultilineTextV2;
+/**
+ * MultilineTextV2 Plugin
+ * Enhanced multiline text plugin using the new plugin system
+ */
+declare class MultilineTextV2 extends EnhancedPlugin {
+    /**
+     * @param {{ jm: import('../jsmind.js').default, pluginOpt: object }} params
+     */
+    constructor({ jm, pluginOpt }: {
+        jm: import("../jsmind.js").default;
+        pluginOpt: object;
+    });
+    options: any;
+    editing_node: import("../jsmind.node.js").Node;
+    multiline_editor: HTMLElement;
+    _original_custom_render: Function | ((jm: import("../jsmind.js").default, ele: HTMLElement, node: import("../jsmind.node.js").Node) => void);
+    _original_edit_node_begin: any;
+    _original_edit_node_end: any;
+    /**
+     * Setup custom rendering in options (for preload plugins)
+     */
+    setupCustomRenderInOptions(): void;
+    /**
+     * Setup custom rendering for multiline text (for normal plugins)
+     */
+    setupCustomRender(): void;
+    /**
+     * Setup edit handlers (common for both preload and normal plugins)
+     */
+    setupEditHandlers(): void;
+    /**
+     * Re-render all nodes to apply multiline styles and recalculate sizes.
+     * This is necessary because node sizes are calculated before custom styles are applied.
+     * @private
+     */
+    private _rerender_all_nodes;
+    /**
+     * Begin editing a node
+     * @param {import('../jsmind.node.js').Node} node
+     */
+    edit_node_begin(node: import("../jsmind.node.js").Node): void;
+    /**
+     * End editing and save changes.
+     */
+    edit_node_end(): void;
+    /**
+     * Cancel editing without saving changes.
+     */
+    cancel_editing(): void;
+    /**
+     * Clean up editor and reset state.
+     * @private
+     */
+    private _cleanup_editor;
+}
+import { EnhancedPlugin } from '../jsmind.enhanced-plugin.js';
+import jsMind from '../jsmind.js';

package/types/generated/plugins/jsmind.multiline-text.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Create a custom node render function for multiline text
+ * @param {MultilineTextOptions} [options={}] - Plugin options
+ * @param {number} [options.text_width=200] - Maximum width for multiline text nodes
+ * @param {string} [options.line_height='1.5'] - Line height for text
+ * @returns {function(jsMind, HTMLElement, Node): boolean} Custom render function
+ * @example
+ * const options = {
+ *     view: {
+ *         custom_node_render: createMultilineRender({
+ *             text_width: 250,
+ *             line_height: '1.6',
+ *         })
+ *     }
+ * };
+ */
+export function createMultilineRender(options?: MultilineTextOptions): (arg0: jsMind, arg1: HTMLElement, arg2: Node) => boolean;
+declare namespace _default {
+    export let name: string;
+    export { init };
+    export { createMultilineRender };
+}
+export default _default;
+/**
+ * Default plugin options
+ */
+export type MultilineTextOptions = {
+    /**
+     * - Maximum width for multiline text nodes (default: 200)
+     */
+    text_width: number;
+    /**
+     * - Line height for text (default: '1.5')
+     */
+    line_height: string;
+};
+/**
+ * Plugin initialization function
+ * @param {import('../jsmind.js').default} jm - jsMind instance
+ * @param {MultilineTextOptions} options - Plugin options
+ * @private
+ */
+declare function init(jm: import("../jsmind.js").default, options: MultilineTextOptions): void;