@umbraci/jsmind 0.10.14 → 0.10.15

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

@@ -0,0 +1,59 @@
+export const $: Dom;
+/**
+ * @license BSD
+ * @copyright 2014-2025 UmbraCi
+ *
+ * Project Home:
+ *   https://github.com/UmbraCi/jsmind/
+ */
+/**
+ * Lightweight DOM helpers bound to a window.
+ */
+declare class Dom {
+    /**
+     * @param {Window} w
+     */
+    constructor(w: Window);
+    /** @type {Window} */
+    w: Window;
+    /** @type {Document} */
+    d: Document;
+    /**
+     * Get element by id.
+     * @param {string} id
+     * @returns {HTMLElement|null}
+     */
+    g: (id: string) => HTMLElement | null;
+    /**
+     * Create element with given tag.
+     * @param {string} tag
+     * @returns {HTMLElement}
+     */
+    c: (tag: string) => HTMLElement;
+    /**
+     * Set text content for element.
+     * @param {HTMLElement} n
+     * @param {string} t
+     */
+    t: (n: HTMLElement, t: string) => void;
+    /**
+     * Set inner HTML or append element.
+     * @param {HTMLElement} n
+     * @param {string|HTMLElement} t
+     */
+    h: (n: HTMLElement, t: string | HTMLElement) => void;
+    /**
+     * Runtime check for HTMLElement.
+     * @param {unknown} el
+     * @returns {el is HTMLElement}
+     */
+    i: (el: unknown) => el is HTMLElement;
+    /**
+     * Add event listener with legacy fallback.
+     * @param {HTMLElement} t
+     * @param {string} e
+     * @param {(ev:Event)=>void} h
+     */
+    on: (t: HTMLElement, e: string, h: (ev: Event) => void) => void;
+}
+export {};

package/types/generated/jsmind.enhanced-plugin.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Enhanced Plugin Manager
+ * Manages the lifecycle of enhanced plugins with synchronous initialization,
+ * preload support, and lifecycle hooks.
+ */
+export class EnhancedPluginManager {
+    /**
+     * @param {import('./jsmind.js').default} jm - jsMind instance
+     */
+    constructor(jm: import("./jsmind.js").default);
+    jm: import("./jsmind.js").default;
+    /** @type {Map<string, EnhancedPlugin>} */
+    plugins: Map<string, EnhancedPlugin>;
+    /**
+     * Initialize preload plugins (before core modules)
+     */
+    initPreloadPlugins(): void;
+    /**
+     * Initialize normal plugins (after core modules)
+     */
+    initNormalPlugins(): void;
+    /**
+     * Internal method: Initialize a single plugin
+     * @param {PluginDescriptor} descriptor
+     * @private
+     */
+    private _initPlugin;
+    /**
+     * Remove a plugin
+     * @param {typeof EnhancedPlugin} PluginClass
+     */
+    removePlugin(PluginClass: typeof EnhancedPlugin): void;
+    /**
+     * Destroy all plugins
+     */
+    destroyAllPlugins(): void;
+    /**
+     * Get plugin instance by name
+     * @param {string} instanceName
+     * @returns {EnhancedPlugin | undefined}
+     */
+    getPlugin(instanceName: string): EnhancedPlugin | undefined;
+}
+/**
+ * Enhanced Plugin Base Class
+ * Provides standard interface for enhanced plugins
+ */
+export class EnhancedPlugin {
+    /**
+     * Plugin instance name (must be defined by subclass)
+     * @type {string}
+     */
+    static instanceName: string;
+    /**
+     * Whether to initialize before core modules
+     * @type {boolean}
+     */
+    static preload: boolean;
+    /**
+     * @param {{ jm: import('./jsmind.js').default, pluginOpt: object }} params
+     */
+    constructor({ jm, pluginOpt }: {
+        jm: import("./jsmind.js").default;
+        pluginOpt: object;
+    });
+    jm: import("./jsmind.js").default;
+    options: any;
+    /**
+     * Called before plugin is removed
+     * Override this method to clean up resources
+     */
+    beforePluginRemove(): void;
+    /**
+     * Called before jsMind instance is destroyed
+     * Override this method to clean up resources
+     */
+    beforePluginDestroy(): void;
+}
+/**
+ * Plugin descriptor
+ */
+export type PluginDescriptor = {
+    /**
+     * - Plugin class
+     */
+    PluginClass: typeof EnhancedPlugin;
+    /**
+     * - Plugin instance name
+     */
+    instanceName: string;
+    /**
+     * - Whether to preload
+     */
+    preload: boolean;
+    /**
+     * - Plugin options
+     */
+    pluginOpt: object;
+    /**
+     * - Plugin instance (after initialization)
+     */
+    instance: EnhancedPlugin | null;
+};

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

@@ -0,0 +1,113 @@
+/**
+ * Mind data format handlers.
+ * @type {{
+ *  node_tree: { example:NodeTreeFormat, get_mind:(src:NodeTreeFormat)=>Mind, get_data:(mind:Mind)=>NodeTreeFormat },
+ *  node_array: { example:NodeArrayFormat, get_mind:(src:NodeArrayFormat)=>Mind, get_data:(mind:Mind)=>NodeArrayFormat },
+ *  freemind: { example:{meta:MindMapMeta,format:'freemind',data:string}, get_mind:(src:{meta?:MindMapMeta,format:'freemind',data:string})=>Mind, get_data:(mind:Mind)=>{meta:MindMapMeta,format:'freemind',data:string} },
+ *  text: { example:{meta:MindMapMeta,format:'text',data:string}, get_mind:(src:{meta?:MindMapMeta,format:'text',data:string})=>Mind, get_data:(mind:Mind)=>{meta:MindMapMeta,format:'text',data:string} }
+ * }}
+ */
+export const format: {
+    node_tree: {
+        example: NodeTreeFormat;
+        get_mind: (src: NodeTreeFormat) => Mind;
+        get_data: (mind: Mind) => NodeTreeFormat;
+    };
+    node_array: {
+        example: NodeArrayFormat;
+        get_mind: (src: NodeArrayFormat) => Mind;
+        get_data: (mind: Mind) => NodeArrayFormat;
+    };
+    freemind: {
+        example: {
+            meta: MindMapMeta;
+            format: "freemind";
+            data: string;
+        };
+        get_mind: (src: {
+            meta?: MindMapMeta;
+            format: "freemind";
+            data: string;
+        }) => Mind;
+        get_data: (mind: Mind) => {
+            meta: MindMapMeta;
+            format: "freemind";
+            data: string;
+        };
+    };
+    text: {
+        example: {
+            meta: MindMapMeta;
+            format: "text";
+            data: string;
+        };
+        get_mind: (src: {
+            meta?: MindMapMeta;
+            format: "text";
+            data: string;
+        }) => Mind;
+        get_data: (mind: Mind) => {
+            meta: MindMapMeta;
+            format: "text";
+            data: string;
+        };
+    };
+};
+export type MindMapMeta = {
+    name: string;
+    author: string;
+    version: string;
+};
+/**
+ * Node tree data item
+ *
+ * Note: When using custom fieldNames configuration, the actual property names
+ * in your data may differ from these type definitions. For example, if you
+ * configure `fieldNames: { topic: 'name' }`, your data should use 'name'
+ * instead of 'topic'. The types shown here represent the default field names.
+ */
+export type NodeTreeData = {
+    id?: string;
+    topic?: string;
+    data?: Record<string, any>;
+    direction?: (number | string);
+    expanded?: boolean;
+    children?: NodeTreeData[];
+    [key: string]: any;
+};
+/**
+ * Node tree formatted payload
+ */
+export type NodeTreeFormat = {
+    meta?: MindMapMeta;
+    format: "node_tree";
+    data: NodeTreeData;
+};
+/**
+ * Node array data item
+ *
+ * Note: When using custom fieldNames configuration, the actual property names
+ * in your data may differ from these type definitions. For example, if you
+ * configure `fieldNames: { topic: 'name', parentid: 'parent' }`, your data
+ * should use 'name' and 'parent' instead of 'topic' and 'parentid'. The types
+ * shown here represent the default field names.
+ */
+export type NodeArrayItem = {
+    id?: string;
+    topic?: string;
+    parentid?: string;
+    data?: Record<string, any>;
+    direction?: (number | string);
+    expanded?: boolean;
+    isroot?: boolean;
+    [key: string]: any;
+};
+/**
+ * Node array formatted payload
+ */
+export type NodeArrayFormat = {
+    meta?: MindMapMeta;
+    format: "node_array";
+    data: NodeArrayItem[];
+};
+import { Mind } from './jsmind.mind.js';

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

@@ -0,0 +1,180 @@
+/**
+ * Initialize graph renderer based on engine type.
+ * @param {import('./jsmind.view_provider.js').ViewProvider} view - View provider instance
+ * @param {'canvas'|'svg'} engine - Rendering engine type
+ * @returns {SvgGraph|CanvasGraph} Graph renderer instance
+ */
+export function init_graph(view: import("./jsmind.view_provider.js").ViewProvider, engine: "canvas" | "svg"): SvgGraph | CanvasGraph;
+/**
+ * SVG-based graph renderer.
+ */
+declare class SvgGraph {
+    /** @param {string} tag */
+    static c(tag: string): SVGElement;
+    /**
+     * Create SVG graph renderer.
+     * @param {import('./jsmind.view_provider.js').ViewProvider} view - View provider instance
+     */
+    constructor(view: import("./jsmind.view_provider.js").ViewProvider);
+    view: import("./jsmind.view_provider.js").ViewProvider;
+    opts: {
+        engine: "canvas" | "svg";
+        enable_device_pixel_ratio: boolean;
+        hmargin: number;
+        vmargin: number;
+        line_width: number;
+        line_color: string;
+        line_style: "curved" | "straight";
+        custom_line_render?: Function;
+        draggable: boolean;
+        hide_scrollbars_when_draggable: boolean;
+        node_overflow: "hidden" | "wrap";
+        zoom: {
+            min: number;
+            max: number;
+            step: number;
+            mask_key: number;
+        };
+        custom_node_render?: Function;
+        expander_style: "char" | "number";
+    };
+    e_svg: SVGElement;
+    size: {
+        w: number;
+        h: number;
+    };
+    /** @type {SVGPathElement[]} */
+    lines: SVGPathElement[];
+    line_drawing: {
+        straight: (path: SVGPathElement, x1: number, y1: number, x2: number, y2: number) => void;
+        curved: (path: SVGPathElement, x1: number, y1: number, x2: number, y2: number) => void;
+    };
+    /** Choose line drawing renderer. */
+    init_line_render(): void;
+    /** @type {(path:SVGPathElement,x1:number,y1:number,x2:number,y2:number)=>void} */
+    drawing: (path: SVGPathElement, x1: number, y1: number, x2: number, y2: number) => void;
+    /** @returns {SVGSVGElement} */
+    element(): SVGSVGElement;
+    /** @param {number} w @param {number} h */
+    set_size(w: number, h: number): void;
+    clear(): void;
+    /** @param {{x:number,y:number}} pout @param {{x:number,y:number}} pin @param {{x:number,y:number}} offset @param {string=} color */
+    draw_line(pout: {
+        x: number;
+        y: number;
+    }, pin: {
+        x: number;
+        y: number;
+    }, offset: {
+        x: number;
+        y: number;
+    }, color?: string | undefined): void;
+    /** @param {CanvasRenderingContext2D} dest_canvas_ctx @param {(()=>void)=} callback */
+    copy_to(dest_canvas_ctx: CanvasRenderingContext2D, callback?: (() => void) | undefined): void;
+    /**
+     * Draw bezier curve to SVG path.
+     * @internal
+     * @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
+     */
+    _bezier_to(path: SVGPathElement, x1: number, y1: number, x2: number, y2: number): void;
+    /**
+     * Draw straight line to SVG path.
+     * @internal
+     * @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
+     */
+    _line_to(path: SVGPathElement, x1: number, y1: number, x2: number, y2: number): void;
+}
+/**
+ * Canvas-based graph renderer.
+ */
+declare class CanvasGraph {
+    /**
+     * Create canvas graph renderer.
+     * @param {import('./jsmind.view_provider.js').ViewProvider} view - View provider instance
+     */
+    constructor(view: import("./jsmind.view_provider.js").ViewProvider);
+    opts: {
+        engine: "canvas" | "svg";
+        enable_device_pixel_ratio: boolean;
+        hmargin: number;
+        vmargin: number;
+        line_width: number;
+        line_color: string;
+        line_style: "curved" | "straight";
+        custom_line_render?: Function;
+        draggable: boolean;
+        hide_scrollbars_when_draggable: boolean;
+        node_overflow: "hidden" | "wrap";
+        zoom: {
+            min: number;
+            max: number;
+            step: number;
+            mask_key: number;
+        };
+        custom_node_render?: Function;
+        expander_style: "char" | "number";
+    };
+    e_canvas: HTMLElement;
+    canvas_ctx: CanvasRenderingContext2D;
+    size: {
+        w: number;
+        h: number;
+    };
+    line_drawing: {
+        straight: (ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number) => void;
+        curved: (ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number) => void;
+    };
+    dpr: number;
+    /** Choose line drawing renderer. */
+    init_line_render(): void;
+    /** @type {(ctx:CanvasRenderingContext2D,x1:number,y1:number,x2:number,y2:number)=>void} */
+    drawing: (ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number) => void;
+    /** @returns {HTMLCanvasElement} */
+    element(): HTMLCanvasElement;
+    /** @param {number} w @param {number} h */
+    set_size(w: number, h: number): void;
+    /** Clear the canvas. */
+    clear(): void;
+    /** @param {{x:number,y:number}} pout @param {{x:number,y:number}} pin @param {{x:number,y:number}} offset @param {string=} color */
+    draw_line(pout: {
+        x: number;
+        y: number;
+    }, pin: {
+        x: number;
+        y: number;
+    }, offset: {
+        x: number;
+        y: number;
+    }, color?: string | undefined): void;
+    /** @param {CanvasRenderingContext2D} dest_canvas_ctx @param {(()=>void)=} callback */
+    copy_to(dest_canvas_ctx: CanvasRenderingContext2D, callback?: (() => void) | undefined): void;
+    /**
+     * Draw bezier curve on canvas.
+     * @internal
+     * @param {CanvasRenderingContext2D} ctx - Canvas context
+     * @param {number} x1 - Start x coordinate
+     * @param {number} y1 - Start y coordinate
+     * @param {number} x2 - End x coordinate
+     * @param {number} y2 - End y coordinate
+     */
+    _bezier_to(ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number): void;
+    /**
+     * Draw straight line on canvas.
+     * @internal
+     * @param {CanvasRenderingContext2D} ctx - Canvas context
+     * @param {number} x1 - Start x coordinate
+     * @param {number} y1 - Start y coordinate
+     * @param {number} x2 - End x coordinate
+     * @param {number} y2 - End y coordinate
+     */
+    _line_to(ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number): void;
+}
+export {};

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

@@ -0,0 +1,182 @@
+export class LayoutProvider {
+    /**
+     * Layout engine for positioning nodes and lines.
+     * @param {import('./jsmind.js').default} jm - jsMind instance
+     * @param {{mode:'full'|'side', hspace:number, vspace:number, pspace:number, cousin_space:number}} options - Layout configuration options
+     */
+    constructor(jm: import("./jsmind.js").default, options: {
+        mode: "full" | "side";
+        hspace: number;
+        vspace: number;
+        pspace: number;
+        cousin_space: number;
+    });
+    opts: {
+        mode: "full" | "side";
+        hspace: number;
+        vspace: number;
+        pspace: number;
+        cousin_space: number;
+    };
+    jm: import("./jsmind.js").default;
+    isside: boolean;
+    bounds: {
+        n: number;
+        s: number;
+        w: number;
+        e: number;
+    };
+    cache_valid: boolean;
+    /** Initialize layout provider. */
+    init(): void;
+    /** Reset layout state and bounds. */
+    reset(): void;
+    /**
+     * Decide the next child's direction for a parent node.
+     * @param {import('./jsmind.node.js').Node} node
+     * @returns {number}
+     */
+    calculate_next_child_direction(node: import("./jsmind.node.js").Node): number;
+    /** Perform layout and offsets recalculation. */
+    layout(): void;
+    /** Calculate and set direction for all nodes. */
+    layout_direction(): void;
+    /**
+     * Set direction layout for root node and its children.
+     * @private
+     */
+    private _layout_direction_root;
+    /**
+     * Set direction layout for a node and its descendants.
+     * @private
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @param {number} direction - Direction constant (-1, 0, 1)
+     * @param {number} side_index - Index among siblings
+     */
+    private _layout_direction_side;
+    /** Calculate and set position offsets for all nodes. */
+    layout_offset(): void;
+    /**
+     * Layout both the x and y axis for subnodes.
+     * @private
+     * @param {import('./jsmind.node.js').Node[]} nodes - Array of nodes to layout
+     * @returns {number} Total height of all nodes
+     */
+    private _layout_offset_subnodes;
+    /**
+     * Layout the y axis only, for collapse/expand a node.
+     * @private
+     * @param {import('./jsmind.node.js').Node[]} nodes - Array of nodes to layout
+     * @returns {number} Total height of all nodes
+     */
+    private _layout_offset_subnodes_height;
+    /**
+     * Check if node should reserve cousin space.
+     * @private
+     * @param {import('./jsmind.node.js').Node} node - Node to check
+     * @returns {boolean} True if cousin space should be reserved
+     */
+    private _should_reserve_cousin_space;
+    /**
+     * Get absolute offset for a node.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {{x:number, y:number}} Absolute position offset
+     */
+    get_node_offset(node: import("./jsmind.node.js").Node): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get anchor point for lines on a node.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {{x:number, y:number}} Anchor point coordinates
+     */
+    get_node_point(node: import("./jsmind.node.js").Node): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get input point for lines on a node.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {{x:number, y:number}} Input point coordinates
+     */
+    get_node_point_in(node: import("./jsmind.node.js").Node): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get output point for lines on a node.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {{x:number, y:number}} Output point coordinates
+     */
+    get_node_point_out(node: import("./jsmind.node.js").Node): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get expander point for a node.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {{x:number, y:number}} Expander point coordinates
+     */
+    get_expander_point(node: import("./jsmind.node.js").Node): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get minimal canvas size to contain all nodes.
+     * @returns {{w:number, h:number}} Minimum size required
+     */
+    get_min_size(): {
+        w: number;
+        h: number;
+    };
+    /**
+     * Toggle node expanded/collapsed state.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     */
+    toggle_node(node: import("./jsmind.node.js").Node): void;
+    /**
+     * Expand a node and show its children.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     */
+    expand_node(node: import("./jsmind.node.js").Node): void;
+    /**
+     * Collapse a node and hide its children.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     */
+    collapse_node(node: import("./jsmind.node.js").Node): void;
+    /** Expand all nodes in the mind map. */
+    expand_all(): void;
+    /** Collapse all nodes in the mind map. */
+    collapse_all(): void;
+    /**
+     * Expand nodes to a specific depth level.
+     * @param {number} target_depth - Target depth level
+     * @param {import('./jsmind.node.js').Node[]=} curr_nodes - Current nodes to process
+     * @param {number=} curr_depth - Current depth level
+     */
+    expand_to_depth(target_depth: number, curr_nodes?: import("./jsmind.node.js").Node[] | undefined, curr_depth?: number | undefined): void;
+    /**
+     * Perform partial layout for a node and its subtree.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     */
+    part_layout(node: import("./jsmind.node.js").Node): void;
+    /**
+     * Set visibility for nodes and their children.
+     * @param {import('./jsmind.node.js').Node[]} nodes - Array of nodes
+     * @param {boolean} visible - Visibility state
+     */
+    set_visible(nodes: import("./jsmind.node.js").Node[], visible: boolean): void;
+    /**
+     * Check if a node is expanded.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {boolean} True if node is expanded
+     */
+    is_expand(node: import("./jsmind.node.js").Node): boolean;
+    /**
+     * Check if a node is visible.
+     * @param {import('./jsmind.node.js').Node} node - Target node
+     * @returns {boolean} True if node is visible
+     */
+    is_visible(node: import("./jsmind.node.js").Node): boolean;
+}