@umbraci/jsmind 0.10.14 → 0.10.15

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.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;

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

@@ -0,0 +1,83 @@
+/**
+ * Screenshot plugin for jsMind.
+ */
+export class JmScreenshot {
+    /**
+     * Create screenshot plugin instance.
+     * @param {import('../jsmind.js').default} jm - jsMind instance
+     * @param {Partial<ScreenshotOptions>} options - Plugin options
+     */
+    constructor(jm: import("../jsmind.js").default, options: Partial<ScreenshotOptions>);
+    version: string;
+    /** @type {import('../jsmind.js').default} */
+    jm: import("../jsmind.js").default;
+    /** @type {ScreenshotOptions} */
+    options: ScreenshotOptions;
+    /** @type {number} */
+    dpr: number;
+    /** Take a screenshot of the mind map. */
+    shoot(): void;
+    /**
+     * Create canvas for screenshot.
+     * @returns {HTMLCanvasElement} Canvas element
+     */
+    create_canvas(): HTMLCanvasElement;
+    /**
+     * Clean up canvas element.
+     * @param {HTMLCanvasElement} c - Canvas to remove
+     */
+    clear(c: HTMLCanvasElement): void;
+    /**
+     * Draw background on canvas.
+     * @param {CanvasRenderingContext2D} ctx - Canvas context
+     * @returns {Promise<CanvasRenderingContext2D>} Promise resolving to context
+     */
+    draw_background(ctx: CanvasRenderingContext2D): Promise<CanvasRenderingContext2D>;
+    /**
+     * Draw connection lines on canvas by copying from view graph.
+     * @param {CanvasRenderingContext2D} ctx
+     * @returns {Promise<CanvasRenderingContext2D>}
+     */
+    draw_lines(ctx: CanvasRenderingContext2D): Promise<CanvasRenderingContext2D>;
+    /**
+     * Draw node DOM into canvas via SVG snapshot.
+     * @param {CanvasRenderingContext2D} ctx
+     * @returns {Promise<CanvasRenderingContext2D>}
+     */
+    draw_nodes(ctx: CanvasRenderingContext2D): Promise<CanvasRenderingContext2D>;
+    /**
+     * Draw watermark text on canvas.
+     * @param {HTMLCanvasElement} c
+     * @param {CanvasRenderingContext2D} ctx
+     * @returns {CanvasRenderingContext2D}
+     */
+    draw_watermark(c: HTMLCanvasElement, ctx: CanvasRenderingContext2D): CanvasRenderingContext2D;
+    /**
+     * Load image from URL and resolve img element.
+     * @param {string} url
+     * @returns {Promise<HTMLImageElement>}
+     */
+    load_image(url: string): Promise<HTMLImageElement>;
+    /**
+     * Trigger download of canvas content as PNG.
+     * @param {HTMLCanvasElement} c
+     */
+    download(c: HTMLCanvasElement): void;
+}
+/**
+ * Screenshot plugin registration.
+ * @type {import('../jsmind.plugin.js').Plugin<Partial<ScreenshotOptions>>}
+ */
+export const screenshot_plugin: import("../jsmind.plugin.js").Plugin<Partial<ScreenshotOptions>>;
+export default JmScreenshot;
+/**
+ * Default options for screenshot plugin.
+ */
+export type ScreenshotOptions = {
+    filename?: string | null;
+    watermark?: {
+        left?: string | Location;
+        right?: string;
+    };
+    background?: string;
+};

package/types/tsconfig.declaration.json

@@ -1,19 +1,19 @@
-{
-    "compilerOptions": {
-        "target": "ES2020",
-        "module": "ESNext",
-        "moduleResolution": "node",
-        "strict": false,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "declaration": true,
-        "emitDeclarationOnly": true,
-        "stripInternal": true,
-        "allowJs": true,
-        "checkJs": false,
-        "rootDirs": ["../src"],
-        "outDir": "./generated",
-        "baseUrl": "."
-    },
-    "include" : ["../src/**/*.ts", "../src/**/*.js"]
-}
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "ESNext",
+        "moduleResolution": "node",
+        "strict": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "stripInternal": true,
+        "allowJs": true,
+        "checkJs": false,
+        "rootDirs": ["../src"],
+        "outDir": "./generated",
+        "baseUrl": "."
+    },
+    "include" : ["../src/**/*.ts", "../src/**/*.js"]
+}