@umbraci/jsmind 0.10.15 → 0.10.17

package/types/generated/jsmind.d.ts

@@ -78,10 +78,6 @@ declare class jsMind {
     version: string;
     initialized: boolean;
     mind: Mind;
-    /** @type {'single'|'multi'|null} */
-    _selection_mode: "single" | "multi" | null;
-    /** @type {import('./jsmind.node.js').Node|null} */
-    _last_selected_node: import("./jsmind.node.js").Node | null;
     /** @type {Array<(type: number, data: EventData) => void>} */
     event_handles: Array<(type: number, data: EventData) => void>;
     /** Initialize sub-systems and plugins. */
@@ -336,24 +332,8 @@ declare class jsMind {
      * @returns {import('./jsmind.node.js').Node|null} Node instance or null
      */
     get_selected_node(): import("./jsmind.node.js").Node | null;
-    /**
-     * Get all currently selected nodes.
-     * @returns {import('./jsmind.node.js').Node[]}
-     */
-    get_selected_nodes(): import("./jsmind.node.js").Node[];
     /** clear selection */
     select_clear(): void;
-    /**
-     * Toggle multi-selection for a node (and optionally descendants).
-     * @param {string | import('./jsmind.node.js').Node} node
-     */
-    toggle_subtree_selection(node: string | import("./jsmind.node.js").Node): void;
-    /**
-     * Determine whether a node is currently selected.
-     * @param {string | import('./jsmind.node.js').Node} node
-     * @returns {boolean}
-     */
-    is_node_selected(node: string | import("./jsmind.node.js").Node): boolean;
     /** @param {string | import('./jsmind.node.js').Node} node */
     is_node_visible(node: string | import("./jsmind.node.js").Node): boolean;
     /**
@@ -361,180 +341,6 @@ declare class jsMind {
      * @param {string | import('./jsmind.node.js').Node} node
      */
     scroll_node_to_center(node: string | import("./jsmind.node.js").Node): void;
-    /**
-     * Add nodes into the current selection set without clearing existing ones.
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    /**
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @param {{focusNode?: import('./jsmind.node.js').Node}=} options
-     * @private
-     */
-    private _append_selection;
-    /**
-     * Remove nodes from the current selection set.
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _remove_selection;
-    /**
-     * Deselect a node and all its descendants from the current selection.
-     * @param {string | import('./jsmind.node.js').Node} node
-     * @private
-     */
-    private _deselect_subtree;
-    /**
-     * Clear all current selections and return the nodes that were cleared.
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _clear_selection_state;
-    /**
-     * Collect a node and optionally its descendants respecting filters.
-     * @param {import('./jsmind.node.js').Node} node
-     * @param {{includeChildren?:boolean, respectFilter?:boolean, skipRootFilter?:boolean}=} config
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _collect_subtree_nodes;
-    /**
-     * Ensure ancestors of provided nodes are also selected (up to first selected ancestor).
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @param {import('./jsmind.node.js').Node=} focusNode
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    /**
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @param {import('./jsmind.node.js').Node=} focusNode
-     * @param {{requireAncestorChainSelected?: boolean}=} options
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _ensure_ancestor_selection;
-    /**
-     * Get the configured selection filter callback, if any.
-     * @returns {((node: import('./jsmind.node.js').Node)=>boolean)|null}
-     * @private
-     */
-    private _get_selection_filter;
-    /**
-     * Determine the multi-select mode based on event modifiers.
-     * Returns: null (single select), 'ctrl' (add/remove), 'shift' (range select)
-     * @param {MouseEvent} e
-     * @returns {null|'ctrl'|'shift'}
-     * @private
-     */
-    private _get_multi_select_mode;
-    /**
-     * Toggle selection of a single node (add if not selected, remove if selected).
-     * Used for Ctrl+Click behavior.
-     * @param {string | import('./jsmind.node.js').Node} node_id
-     * @private
-     */
-    private _toggle_node_selection;
-    /**
-     * Range select nodes for Shift+Click behavior.
-     * Logic:
-     * - If no nodes are currently selected: select all nodes under the clicked node
-     * - If nodes are already selected: select nodes in the range from first selected to clicked node
-     * @param {string | import('./jsmind.node.js').Node} node_id
-     * @private
-     */
-    private _range_select_nodes;
-    /**
-     * Find all nodes between two nodes (for range selection).
-     * This includes both nodes and all nodes in between them in tree order.
-     * @param {import('./jsmind.node.js').Node} node1
-     * @param {import('./jsmind.node.js').Node} node2
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _find_nodes_between;
-    /**
-     * Check whether ancestor is an ancestor of node.
-     * @param {import('./jsmind.node.js').Node} ancestor
-     * @param {import('./jsmind.node.js').Node} node
-     * @returns {boolean}
-     * @private
-     */
-    private _is_ancestor_of;
-    /**
-     * Return nodes along the ancestor->descendant chain, inclusive. If 'ancestor' is not actually
-     * an ancestor of 'descendant', returns empty array.
-     * @param {import('./jsmind.node.js').Node} ancestor
-     * @param {import('./jsmind.node.js').Node} descendant
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _get_path_nodes;
-    /**
-     * Find nearest selected ancestor of the given node from current selection set.
-     * @param {import('./jsmind.node.js').Node} node
-     * @returns {import('./jsmind.node.js').Node|null}
-     * @private
-     */
-    private _find_nearest_selected_ancestor;
-    /**
-     * Find lowest common ancestor of two nodes.
-     * @param {import('./jsmind.node.js').Node} a
-     * @param {import('./jsmind.node.js').Node} b
-     * @returns {import('./jsmind.node.js').Node|null}
-     * @private
-     */
-    private _find_lca;
-    /**
-     * Given a lowest common ancestor 'lca' and a descendant 'node',
-     * return the direct child of lca that lies on the path to node.
-     * Returns null if node is not a descendant of lca or node === lca.
-     * @param {import('./jsmind.node.js').Node} lca
-     * @param {import('./jsmind.node.js').Node} node
-     * @returns {import('./jsmind.node.js').Node|null}
-     * @private
-     */
-    private _child_on_path;
-    /**
-     * From a list of nodes, remove those that are ancestors of any other node in the same list.
-     * Keeps only the deepest nodes so that we don't auto-select parents implicitly.
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _remove_ancestor_nodes;
-    /**
-     * From a list of nodes, remove those that are descendants of any other node in the same list.
-     * Keeps only top-most nodes so that expanding subtrees covers full branches across siblings.
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @returns {import('./jsmind.node.js').Node[]}
-     * @private
-     */
-    private _remove_descendant_nodes;
-    /**
-     * Expand a set of base nodes with all their descendants (and themselves).
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @param {{respectFilter?: boolean}=} opts
-     * @returns {Set<import('./jsmind.node.js').Node>}
-     * @private
-     */
-    private _expand_with_descendants;
-    /**
-     * Promote parents into selection ONLY when all their direct children are selected
-     * AND at least one ancestor of that parent is already selected (in previous selection set).
-     * This avoids auto-selecting parents when only siblings are selected.
-     * @param {Set<import('./jsmind.node.js').Node>} set
-     * @returns {Set<import('./jsmind.node.js').Node>}
-     * @private
-     */
-    private _promote_parents_when_children_selected;
-    /**
-     * Determine selection mode based on current selection size.
-     * @returns {'single'|'multi'|null}
-     * @private
-     */
-    private _derive_selection_mode;
     /**
      * Find the previous sibling node of the given node.
      *

package/types/generated/jsmind.mind.d.ts

@@ -9,8 +9,6 @@ export class Mind {
     root: Node | null;
     /** @type {Node | null} */
     selected: Node | null;
-    /** @type {Set<Node>} */
-    selected_nodes: Set<Node>;
     /** @type {Record<string, Node>} */
     nodes: Record<string, Node>;
     /**
@@ -108,12 +106,6 @@ export class Mind {
      * @returns {boolean}
      */
     remove_node(node: Node): boolean;
-    /**
-     * Remove a node and its subtree from the cached selection set.
-     * @param {Node} node
-     * @private
-     */
-    private _purge_selection;
     /**
      * Put node into the map if id is not taken.
      * @param {Node} node

package/types/generated/jsmind.option.d.ts

@@ -60,11 +60,6 @@ export type JsMindRuntimeOptions = {
         mapping?: Record<string, number | number[]>;
         id_generator?: () => string;
     };
-    selection?: {
-        enable_multi_select?: boolean;
-        include_descendants?: boolean;
-        filter?: (node: import("./jsmind.node.js").Node) => boolean;
-    };
     fieldNames?: {
         id?: string;
         topic?: string;

package/types/generated/jsmind.view_provider.d.ts

@@ -71,8 +71,6 @@ export class ViewProvider {
         h: number;
     };
     selected_node: import("./jsmind.node.js").Node;
-    /** @type {Map<string, import('./jsmind.node.js').Node>} */
-    multi_selected_nodes: Map<string, import("./jsmind.node.js").Node>;
     editing_node: import("./jsmind.node.js").Node;
     graph: {
         view: ViewProvider;
@@ -255,19 +253,6 @@ export class ViewProvider {
     select_node(node: import("./jsmind.node.js").Node | null): void;
     /** Clear node selection. */
     select_clear(): void;
-    /**
-     * Append nodes to the current selection without clearing existing ones.
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     * @param {import('./jsmind.node.js').Node=} focus_node
-     */
-    append_selected_nodes(nodes: import("./jsmind.node.js").Node[], focus_node?: import("./jsmind.node.js").Node | undefined): void;
-    /**
-     * Remove the provided nodes from selection state.
-     * @param {import('./jsmind.node.js').Node[]} nodes
-     */
-    remove_selected_nodes(nodes: import("./jsmind.node.js").Node[]): void;
-    /** Clear all selections at once. */
-    clear_all_selected_nodes(): void;
     /**
      * Get currently editing node.
      * @returns {import('./jsmind.node.js').Node|null} Currently editing node
@@ -344,18 +329,6 @@ export class ViewProvider {
     restore_selected_node_custom_style(node: import("./jsmind.node.js").Node): void;
     /** @param {import('./jsmind.node.js').Node} node */
     clear_selected_node_custom_style(node: import("./jsmind.node.js").Node): void;
-    /**
-     * Mark the DOM/state for a selected node.
-     * @param {import('./jsmind.node.js').Node} node
-     * @private
-     */
-    private _mark_node_selected;
-    /**
-     * Remove DOM/state selection for a node.
-     * @param {import('./jsmind.node.js').Node} node
-     * @private
-     */
-    private _unmark_node_selected;
     clear_lines(): void;
     show_lines(): void;
     /**

package/types/generated/plugins/history/history-diff.d.ts

@@ -23,6 +23,7 @@
 export function flatten(tree: NodeTreeFormat | NodeTreeData, opts?: FlattenOptions): Map<string, FlatNode>;
 /**
  * Compute diff between two snapshots.
+ * Always categorizes updates into moved/modified/movedAndModified using LIS algorithm for precise move detection.
  *
  * Note: When using custom fieldNames, make sure to pass the correct field names in opts.fields.
  * For example, if you configured fieldNames: { topic: 'name' }, you should pass fields: ['name', 'data', 'id'].
@@ -31,22 +32,26 @@ export function flatten(tree: NodeTreeFormat | NodeTreeData, opts?: FlattenOptio
  * @param {NodeTreeFormat|NodeTreeData} a - First snapshot (before)
  * @param {NodeTreeFormat|NodeTreeData} b - Second snapshot (after)
  * @param {DiffOptions} [opts] - Diff options
- * @returns {DiffResult} Diff result with created, updated, deleted nodes, and optionally categorized updates
+ * @returns {DiffResult} Diff result with created, deleted, moved, modified, and movedAndModified nodes
  *
  * @example
  * // Basic usage with default fieldNames
  * const result = diff(snapshot1, snapshot2);
  * console.log(result.created); // Newly created nodes
- * console.log(result.updated); // Updated nodes with changes
  * console.log(result.deleted); // Deleted nodes
- *
- * @example
- * // With categorization
- * const result = diff(snapshot1, snapshot2, { categorize: true });
- * console.log(result.moved); // Nodes that were only moved
+ * console.log(result.moved); // Nodes that were only moved (cross-parent or reordered)
  * console.log(result.modified); // Nodes that were only modified
  * console.log(result.movedAndModified); // Nodes that were both moved and modified
  *
+ * // Check move type
+ * result.moved.forEach(node => {
+ *   if (node.moveInfo.moveType === 'cross-parent') {
+ *     console.log(`${node.id} moved from ${node.moveInfo.fromParent} to ${node.moveInfo.toParent}`);
+ *   } else if (node.moveInfo.moveType === 'reorder') {
+ *     console.log(`${node.id} reordered from index ${node.moveInfo.fromOrder} to ${node.moveInfo.toOrder}`);
+ *   }
+ * });
+ *
  * @example
  * // With custom fieldNames: { topic: 'name' }
  * const result = diff(snapshot1, snapshot2, { fields: ['name', 'data', 'id'] });
@@ -58,12 +63,7 @@ export function flatten(tree: NodeTreeFormat | NodeTreeData, opts?: FlattenOptio
  * // ... make changes ...
  * const after = jm.get_data('node_tree');
  * const result = jm.history.diff(before, after);
- * // fieldNames are automatically applied, no need to specify fields manually
- *
- * @example
- * // Ignore index changes caused by preceding node deletions
- * const result = jm.history.diff(before, after, { ignoreDeletionShift: true });
- * // Now nodes that only change index due to deletion of previous siblings won't be marked as moved
+ * // fieldNames are automatically applied, LIS algorithm is used for precise move detection
  */
 export function diff(a: NodeTreeFormat | NodeTreeData, b: NodeTreeFormat | NodeTreeData, opts?: DiffOptions): DiffResult;
 export type NodeTreeFormat = {
@@ -135,6 +135,10 @@ export type UpdatedNode = {
     changes: ChangeDetail[];
 };
 export type MoveInfo = {
+    /**
+     * - Type of move: 'cross-parent' for different parent, 'reorder' for same parent
+     */
+    moveType: "cross-parent" | "reorder";
     /**
      * - Whether parent changed
      */
@@ -223,10 +227,6 @@ export type DiffResult = {
      * - Newly created nodes
      */
     created: FlatNode[];
-    /**
-     * - Updated nodes (all changes)
-     */
-    updated: UpdatedNode[];
     /**
      * - Deleted nodes
      */
@@ -236,17 +236,17 @@ export type DiffResult = {
      */
     truncated: boolean;
     /**
-     * - Nodes that were only moved (when categorize=true)
+     * - Nodes that were only moved
      */
-    moved?: MovedNode[];
+    moved: MovedNode[];
     /**
-     * - Nodes that were only modified (when categorize=true)
+     * - Nodes that were only modified
      */
-    modified?: ModifiedNode[];
+    modified: ModifiedNode[];
     /**
-     * - Nodes that were both moved and modified (when categorize=true)
+     * - Nodes that were both moved and modified
      */
-    movedAndModified?: MovedAndModifiedNode[];
+    movedAndModified: MovedAndModifiedNode[];
 };
 export type FlattenOptions = {
     /**
@@ -273,21 +273,16 @@ export type FlattenOptions = {
 export type DiffOptions = {
     /**
      * - Array of field names to compare. Defaults to ['topic', 'data', 'id'].
-     *     When using custom fieldNames (e.g., { id: 'key', topic: 'name' }), this should be
-     *     ['name', 'data', 'key'] to match the actual field names in the data.
-     *     Note: When using jm.history.diff(), this is automatically handled based
-     *     on the configured fieldNames, so you don't need to specify it manually.
+     *     Note: When using jm.history.diff(), this is automatically handled.
      */
     fields?: string[];
     /**
      * - The field name to use as the node ID. Defaults to 'id'.
-     *     When using custom fieldNames (e.g., { id: 'key' }), this should be 'key'.
      *     Note: When using jm.history.diff(), this is automatically handled.
      */
     idKey?: string;
     /**
      * - The field name to use for children array. Defaults to 'children'.
-     *     When using custom fieldNames (e.g., { children: 'items' }), this should be 'items'.
      *     Note: When using jm.history.diff(), this is automatically handled.
      */
     childrenKey?: string;
@@ -299,12 +294,4 @@ export type DiffOptions = {
      * - Maximum number of diff results. Defaults to 5000
      */
     maxSize?: number;
-    /**
-     * - Whether to categorize updates into moved/modified/movedAndModified. Defaults to false
-     */
-    categorize?: boolean;
-    /**
-     * - Whether to ignore index changes caused by preceding node deletions. When true, nodes that only change index due to deletion of previous siblings won't be marked as moved. Defaults to false
-     */
-    ignoreDeletionShift?: 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;
+}