jqtree 1.8.8 → 1.8.10

package/src/nodeElement/index.ts

@@ -1,7 +1,6 @@
 import { DropHint } from "../dragAndDropHandler/types";
 import { GetScrollLeft } from "../jqtreeMethodTypes";
-import { Node } from "../node";
-import { Position } from "../position";
+import { Node, Position } from "../node";
 import BorderDropHint from "./borderDropHint";
 import GhostDropHint from "./ghostDropHint";
 
@@ -13,11 +12,11 @@ export interface NodeElementParams {
 }
 
 class NodeElement {
+    public element: HTMLElement;
+    public node: Node;
     private getScrollLeft: GetScrollLeft;
     private tabIndex?: number;
     private treeElement: HTMLElement;
-    public element: HTMLElement;
-    public node: Node;
 
     constructor({
         getScrollLeft,
@@ -32,21 +31,7 @@ class NodeElement {
         this.init(node);
     }
 
-    protected getTitleSpan(): HTMLSpanElement {
-        return this.element.querySelector(
-            ":scope > .jqtree-element > span.jqtree-title",
-        ) as HTMLSpanElement;
-    }
-
-    protected getUl(): HTMLUListElement {
-        return this.element.querySelector(":scope > ul") as HTMLUListElement;
-    }
-
-    protected mustShowBorderDropHint(position: Position): boolean {
-        return position === Position.Inside;
-    }
-
-    public addDropHint(position: number): DropHint {
+    public addDropHint(position: Position): DropHint {
         if (this.mustShowBorderDropHint(position)) {
             return new BorderDropHint(this.element, this.getScrollLeft());
         } else {
@@ -91,6 +76,20 @@ class NodeElement {
             titleSpan.focus();
         }
     }
+
+    protected getTitleSpan(): HTMLSpanElement {
+        return this.element.querySelector(
+            ":scope > .jqtree-element > span.jqtree-title",
+        ) as HTMLSpanElement;
+    }
+
+    protected getUl(): HTMLUListElement {
+        return this.element.querySelector(":scope > ul") as HTMLUListElement;
+    }
+
+    protected mustShowBorderDropHint(position: Position): boolean {
+        return position === "inside";
+    }
 }
 
 export default NodeElement;

package/src/saveStateHandler.ts

@@ -65,76 +65,6 @@ export default class SaveStateHandler {
         this.saveStateOption = saveState;
     }
 
-    private getKeyName(): string {
-        if (typeof this.saveStateOption === "string") {
-            return this.saveStateOption;
-        } else {
-            return "tree";
-        }
-    }
-
-    private loadFromStorage(): null | string {
-        if (this.onGetStateFromStorage) {
-            return this.onGetStateFromStorage();
-        } else {
-            return localStorage.getItem(this.getKeyName());
-        }
-    }
-
-    private openInitialNodes(nodeIds: NodeId[]): boolean {
-        let mustLoadOnDemand = false;
-
-        for (const nodeId of nodeIds) {
-            const node = this.getNodeById(nodeId);
-
-            if (node) {
-                if (!node.load_on_demand) {
-                    node.is_open = true;
-                } else {
-                    mustLoadOnDemand = true;
-                }
-            }
-        }
-
-        return mustLoadOnDemand;
-    }
-
-    private parseState(jsonData: string): SavedState {
-        const state = JSON.parse(jsonData) as Record<string, unknown>;
-
-        // Check if selected_node is an int (instead of an array)
-        if (state.selected_node && isInt(state.selected_node)) {
-            // Convert to array
-            state.selected_node = [state.selected_node];
-        }
-
-        return state as unknown as SavedState;
-    }
-
-    private resetSelection(): void {
-        const selectedNodes = this.getSelectedNodes();
-
-        selectedNodes.forEach((node) => {
-            this.removeFromSelection(node);
-        });
-    }
-
-    private selectInitialNodes(nodeIds: NodeId[]): boolean {
-        let selectCount = 0;
-
-        for (const nodeId of nodeIds) {
-            const node = this.getNodeById(nodeId);
-
-            if (node) {
-                selectCount += 1;
-
-                this.addToSelection(node);
-            }
-        }
-
-        return selectCount !== 0;
-    }
-
     public getNodeIdToBeSelected(): NodeId | null {
         const state = this.getStateFromStorage();
 
@@ -272,4 +202,74 @@ export default class SaveStateHandler {
 
         openNodes();
     }
+
+    private getKeyName(): string {
+        if (typeof this.saveStateOption === "string") {
+            return this.saveStateOption;
+        } else {
+            return "tree";
+        }
+    }
+
+    private loadFromStorage(): null | string {
+        if (this.onGetStateFromStorage) {
+            return this.onGetStateFromStorage();
+        } else {
+            return localStorage.getItem(this.getKeyName());
+        }
+    }
+
+    private openInitialNodes(nodeIds: NodeId[]): boolean {
+        let mustLoadOnDemand = false;
+
+        for (const nodeId of nodeIds) {
+            const node = this.getNodeById(nodeId);
+
+            if (node) {
+                if (!node.load_on_demand) {
+                    node.is_open = true;
+                } else {
+                    mustLoadOnDemand = true;
+                }
+            }
+        }
+
+        return mustLoadOnDemand;
+    }
+
+    private parseState(jsonData: string): SavedState {
+        const state = JSON.parse(jsonData) as Record<string, unknown>;
+
+        // Check if selected_node is an int (instead of an array)
+        if (state.selected_node && isInt(state.selected_node)) {
+            // Convert to array
+            state.selected_node = [state.selected_node];
+        }
+
+        return state as unknown as SavedState;
+    }
+
+    private resetSelection(): void {
+        const selectedNodes = this.getSelectedNodes();
+
+        selectedNodes.forEach((node) => {
+            this.removeFromSelection(node);
+        });
+    }
+
+    private selectInitialNodes(nodeIds: NodeId[]): boolean {
+        let selectCount = 0;
+
+        for (const nodeId of nodeIds) {
+            const node = this.getNodeById(nodeId);
+
+            if (node) {
+                selectCount += 1;
+
+                this.addToSelection(node);
+            }
+        }
+
+        return selectCount !== 0;
+    }
 }

package/src/scrollHandler/containerScrollParent.ts

@@ -3,13 +3,13 @@ import type { ScrollParent } from "./types";
 import { getElementPosition, getOffsetTop } from '../util'
 
 type HorizontalScrollDirection = "left" | "right";
-type VerticalScrollDirection = "bottom" | "top";
-
 interface Params {
     container: HTMLElement;
     refreshHitAreas: () => void;
 }
 
+type VerticalScrollDirection = "bottom" | "top";
+
 export default class ContainerScrollParent implements ScrollParent {
     private container: HTMLElement;
     private horizontalScrollDirection?: HorizontalScrollDirection;
@@ -25,6 +25,62 @@ export default class ContainerScrollParent implements ScrollParent {
         this.refreshHitAreas = refreshHitAreas;
     }
 
+    public checkHorizontalScrolling(pageX: number): void {
+        const newHorizontalScrollDirection =
+            this.getNewHorizontalScrollDirection(pageX);
+
+        if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
+            this.horizontalScrollDirection = newHorizontalScrollDirection;
+
+            if (this.horizontalScrollTimeout != null) {
+                window.clearTimeout(this.verticalScrollTimeout);
+            }
+
+            if (newHorizontalScrollDirection) {
+                this.horizontalScrollTimeout = window.setTimeout(
+                    this.scrollHorizontally.bind(this),
+                    40,
+                );
+            }
+        }
+    }
+
+    public checkVerticalScrolling(pageY: number) {
+        const newVerticalScrollDirection =
+            this.getNewVerticalScrollDirection(pageY);
+
+        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
+            this.verticalScrollDirection = newVerticalScrollDirection;
+
+            if (this.verticalScrollTimeout != null) {
+                window.clearTimeout(this.verticalScrollTimeout);
+                this.verticalScrollTimeout = undefined;
+            }
+
+            if (newVerticalScrollDirection) {
+                this.verticalScrollTimeout = window.setTimeout(
+                    this.scrollVertically.bind(this),
+                    40,
+                );
+            }
+        }
+    }
+
+    public getScrollLeft(): number {
+        return this.container.scrollLeft;
+    }
+
+    public scrollToY(top: number): void {
+        this.container.scrollTop = top;
+    }
+
+    public stopScrolling() {
+        this.horizontalScrollDirection = undefined;
+        this.verticalScrollDirection = undefined;
+        this.scrollParentTop = undefined;
+        this.scrollParentBottom = undefined;
+    }
+
     private getNewHorizontalScrollDirection(
         pageX: number,
     ): HorizontalScrollDirection | undefined {
@@ -109,60 +165,4 @@ export default class ContainerScrollParent implements ScrollParent {
 
         setTimeout(this.scrollVertically.bind(this), 40);
     }
-
-    public checkHorizontalScrolling(pageX: number): void {
-        const newHorizontalScrollDirection =
-            this.getNewHorizontalScrollDirection(pageX);
-
-        if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
-            this.horizontalScrollDirection = newHorizontalScrollDirection;
-
-            if (this.horizontalScrollTimeout != null) {
-                window.clearTimeout(this.verticalScrollTimeout);
-            }
-
-            if (newHorizontalScrollDirection) {
-                this.horizontalScrollTimeout = window.setTimeout(
-                    this.scrollHorizontally.bind(this),
-                    40,
-                );
-            }
-        }
-    }
-
-    public checkVerticalScrolling(pageY: number) {
-        const newVerticalScrollDirection =
-            this.getNewVerticalScrollDirection(pageY);
-
-        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
-            this.verticalScrollDirection = newVerticalScrollDirection;
-
-            if (this.verticalScrollTimeout != null) {
-                window.clearTimeout(this.verticalScrollTimeout);
-                this.verticalScrollTimeout = undefined;
-            }
-
-            if (newVerticalScrollDirection) {
-                this.verticalScrollTimeout = window.setTimeout(
-                    this.scrollVertically.bind(this),
-                    40,
-                );
-            }
-        }
-    }
-
-    public getScrollLeft(): number {
-        return this.container.scrollLeft;
-    }
-
-    public scrollToY(top: number): void {
-        this.container.scrollTop = top;
-    }
-
-    public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
-        this.scrollParentTop = undefined;
-        this.scrollParentBottom = undefined;
-    }
 }

package/src/scrollHandler/documentScrollParent.ts

@@ -3,13 +3,13 @@ import type { ScrollParent } from "./types";
 import { getOffsetTop } from "../util";
 
 type HorizontalScrollDirection = "left" | "right";
-type VerticalScrollDirection = "bottom" | "top";
-
 interface Params {
     refreshHitAreas: () => void;
     treeElement: HTMLElement;
 }
 
+type VerticalScrollDirection = "bottom" | "top";
+
 export default class DocumentScrollParent implements ScrollParent {
     private documentScrollHeight?: number;
     private documentScrollWidth?: number;
@@ -25,6 +25,64 @@ export default class DocumentScrollParent implements ScrollParent {
         this.treeElement = treeElement;
     }
 
+    public checkHorizontalScrolling(pageX: number): void {
+        const newHorizontalScrollDirection =
+            this.getNewHorizontalScrollDirection(pageX);
+
+        if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
+            this.horizontalScrollDirection = newHorizontalScrollDirection;
+
+            if (this.horizontalScrollTimeout != null) {
+                window.clearTimeout(this.horizontalScrollTimeout);
+            }
+
+            if (newHorizontalScrollDirection) {
+                this.horizontalScrollTimeout = window.setTimeout(
+                    this.scrollHorizontally.bind(this),
+                    40,
+                );
+            }
+        }
+    }
+
+    public checkVerticalScrolling(pageY: number) {
+        const newVerticalScrollDirection =
+            this.getNewVerticalScrollDirection(pageY);
+
+        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
+            this.verticalScrollDirection = newVerticalScrollDirection;
+
+            if (this.verticalScrollTimeout != null) {
+                window.clearTimeout(this.verticalScrollTimeout);
+                this.verticalScrollTimeout = undefined;
+            }
+
+            if (newVerticalScrollDirection) {
+                this.verticalScrollTimeout = window.setTimeout(
+                    this.scrollVertically.bind(this),
+                    40,
+                );
+            }
+        }
+    }
+
+    public getScrollLeft(): number {
+        return document.documentElement.scrollLeft;
+    }
+
+    public scrollToY(top: number): void {
+        const treeTop = getOffsetTop(this.treeElement);
+
+        document.documentElement.scrollTop = top + treeTop;
+    }
+
+    public stopScrolling() {
+        this.horizontalScrollDirection = undefined;
+        this.verticalScrollDirection = undefined;
+        this.documentScrollHeight = undefined;
+        this.documentScrollWidth = undefined;
+    }
+
     private canScrollDown() {
         const documentElement = document.documentElement;
 
@@ -125,62 +183,4 @@ export default class DocumentScrollParent implements ScrollParent {
 
         setTimeout(this.scrollVertically.bind(this), 40);
     }
-
-    public checkHorizontalScrolling(pageX: number): void {
-        const newHorizontalScrollDirection =
-            this.getNewHorizontalScrollDirection(pageX);
-
-        if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
-            this.horizontalScrollDirection = newHorizontalScrollDirection;
-
-            if (this.horizontalScrollTimeout != null) {
-                window.clearTimeout(this.horizontalScrollTimeout);
-            }
-
-            if (newHorizontalScrollDirection) {
-                this.horizontalScrollTimeout = window.setTimeout(
-                    this.scrollHorizontally.bind(this),
-                    40,
-                );
-            }
-        }
-    }
-
-    public checkVerticalScrolling(pageY: number) {
-        const newVerticalScrollDirection =
-            this.getNewVerticalScrollDirection(pageY);
-
-        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
-            this.verticalScrollDirection = newVerticalScrollDirection;
-
-            if (this.verticalScrollTimeout != null) {
-                window.clearTimeout(this.verticalScrollTimeout);
-                this.verticalScrollTimeout = undefined;
-            }
-
-            if (newVerticalScrollDirection) {
-                this.verticalScrollTimeout = window.setTimeout(
-                    this.scrollVertically.bind(this),
-                    40,
-                );
-            }
-        }
-    }
-
-    public getScrollLeft(): number {
-        return document.documentElement.scrollLeft;
-    }
-
-    public scrollToY(top: number): void {
-        const treeTop = getOffsetTop(this.treeElement);
-
-        document.documentElement.scrollTop = top + treeTop;
-    }
-
-    public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
-        this.documentScrollHeight = undefined;
-        this.documentScrollWidth = undefined;
-    }
 }

package/src/scrollHandler.ts

@@ -18,6 +18,23 @@ export default class ScrollHandler {
         this.treeElement = treeElement;
     }
 
+    public checkScrolling(positionInfo: PositionInfo): void {
+        this.checkVerticalScrolling(positionInfo);
+        this.checkHorizontalScrolling(positionInfo);
+    }
+
+    public getScrollLeft(): number {
+        return this.getScrollParent().getScrollLeft();
+    }
+
+    public scrollToY(top: number): void {
+        this.getScrollParent().scrollToY(top);
+    }
+
+    public stopScrolling() {
+        this.getScrollParent().stopScrolling();
+    }
+
     private checkHorizontalScrolling(positionInfo: PositionInfo): void {
         this.getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
     }
@@ -36,21 +53,4 @@ export default class ScrollHandler {
 
         return this.scrollParent;
     }
-
-    public checkScrolling(positionInfo: PositionInfo): void {
-        this.checkVerticalScrolling(positionInfo);
-        this.checkHorizontalScrolling(positionInfo);
-    }
-
-    public getScrollLeft(): number {
-        return this.getScrollParent().getScrollLeft();
-    }
-
-    public scrollToY(top: number): void {
-        this.getScrollParent().scrollToY(top);
-    }
-
-    public stopScrolling() {
-        this.getScrollParent().stopScrolling();
-    }
 }

package/src/tree.jquery.d.ts

@@ -1,31 +1,3 @@
-type NodeId = number | string;
-
-interface NodeRecord {
-    [key: string]: unknown;
-    children?: NodeData[];
-    id?: NodeId;
-}
-
-type NodeData = NodeRecord | string;
-
-type IterateCallback = (node: INode, level: number) => boolean;
-
-interface INode {
-    [key: string]: unknown;
-    children: INode[];
-    element?: HTMLElement;
-    id?: NodeId;
-    is_open: boolean;
-    iterate(callback: IterateCallback): void;
-
-    name: string;
-
-    parent: INode | null;
-}
-
-type DataUrlFunction = (node?: Node) => JQuery.AjaxSettings;
-type DataUrl = DataUrlFunction | JQuery.AjaxSettings | string;
-
 interface ClickNodeEvent {
     click_event: JQuery.ClickEvent;
     deselected_node?: INode | null;
@@ -33,15 +5,9 @@ interface ClickNodeEvent {
     previous_node?: INode;
 }
 
-interface SelectNodeOptions {
-    mustSetFocus?: boolean;
-    mustToggle?: boolean;
-}
+type DataUrl = DataUrlFunction | JQuery.AjaxSettings | string;
 
-interface SavedState {
-    open_nodes: NodeId[];
-    selected_node: NodeId[];
-}
+type DataUrlFunction = (node?: Node) => JQuery.AjaxSettings;
 
 interface IJQTreeOptions {
     animationSpeed?: number | string;
@@ -126,7 +92,7 @@ interface IJQTreePlugin {
         behavior: "moveNode",
         node: INode,
         targetNode: INode,
-        position: string,
+        position: "after" | "before" | "inside",
     ): JQuery;
     (behavior: "moveUp"): JQuery;
     (behavior: "openNode", node: INode): JQuery;
@@ -160,6 +126,40 @@ interface IJQTreePlugin {
     (behavior: "updateNode", node: INode, data: NodeData): JQuery;
 }
 
+interface INode {
+    [key: string]: unknown;
+    children: INode[];
+    element?: HTMLElement;
+    id?: NodeId;
+    is_open: boolean;
+    iterate(callback: IterateCallback): void;
+
+    name: string;
+
+    parent: INode | null;
+}
+type IterateCallback = (node: INode, level: number) => boolean;
+
 interface JQuery {
     tree: IJQTreePlugin;
 }
+
+type NodeData = NodeRecord | string;
+
+type NodeId = number | string;
+
+interface NodeRecord {
+    [key: string]: unknown;
+    children?: NodeData[];
+    id?: NodeId;
+}
+
+interface SavedState {
+    open_nodes: NodeId[];
+    selected_node: NodeId[];
+}
+
+interface SelectNodeOptions {
+    mustSetFocus?: boolean;
+    mustToggle?: boolean;
+}