jqtree 1.8.7 → 1.8.9

package/src/nodeElement/ghostDropHint.ts

@@ -1,6 +1,5 @@
 import { DropHint } from "../dragAndDropHandler/types";
-import { Node } from "../node";
-import { Position } from "../position";
+import { Node, Position } from "../node";
 
 class GhostDropHint implements DropHint {
     private element: HTMLElement;
@@ -13,15 +12,15 @@ class GhostDropHint implements DropHint {
         this.ghost = this.createGhostElement();
 
         switch (position) {
-            case Position.After:
+            case "after":
                 this.moveAfter();
                 break;
 
-            case Position.Before:
+            case "before":
                 this.moveBefore();
                 break;
 
-            case Position.Inside: {
+            case "inside": {
                 if (node.isFolder() && node.is_open) {
                     this.moveInsideOpenFolder();
                 } else {
@@ -31,6 +30,10 @@ class GhostDropHint implements DropHint {
         }
     }
 
+    public remove(): void {
+        this.ghost.remove();
+    }
+
     private createGhostElement() {
         const ghost = document.createElement("li");
         ghost.className = "jqtree_common jqtree-ghost";
@@ -66,10 +69,6 @@ class GhostDropHint implements DropHint {
             childElement.before(this.ghost);
         }
     }
-
-    public remove(): void {
-        this.ghost.remove();
-    }
 }
 
 export default GhostDropHint;

package/src/nodeElement/index.ts

@@ -1,52 +1,37 @@
 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";
 
 export interface NodeElementParams {
-    $treeElement: JQuery;
     getScrollLeft: GetScrollLeft;
     node: Node;
     tabIndex?: number;
+    treeElement: HTMLElement;
 }
 
 class NodeElement {
-    private $treeElement: JQuery;
-    private getScrollLeft: GetScrollLeft;
-    private tabIndex?: number;
     public element: HTMLElement;
     public node: Node;
+    private getScrollLeft: GetScrollLeft;
+    private tabIndex?: number;
+    private treeElement: HTMLElement;
 
     constructor({
-        $treeElement,
         getScrollLeft,
         node,
         tabIndex,
+        treeElement,
     }: NodeElementParams) {
         this.getScrollLeft = getScrollLeft;
         this.tabIndex = tabIndex;
-        this.$treeElement = $treeElement;
+        this.treeElement = treeElement;
 
         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 {
@@ -68,16 +53,10 @@ class NodeElement {
         this.node = node;
 
         if (!node.element) {
-            const element = this.$treeElement.get(0);
-
-            if (element) {
-                node.element = element;
-            }
+            node.element = this.treeElement;
         }
 
-        if (node.element) {
-            this.element = node.element;
-        }
+        this.element = node.element;
     }
 
     public select(mustSetFocus: boolean): void {
@@ -97,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

@@ -30,7 +30,6 @@ interface SaveStateHandlerParams {
 }
 
 export default class SaveStateHandler {
-    private _supportsLocalStorage: boolean | null;
     private addToSelection: AddToSelection;
     private getNodeById: GetNodeById;
     private getSelectedNodes: GetSelectedNodes;
@@ -66,99 +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 if (this.supportsLocalStorage()) {
-            return localStorage.getItem(this.getKeyName());
-        } else {
-            return null;
-        }
-    }
-
-    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;
-    }
-
-    private supportsLocalStorage(): boolean {
-        const testSupport = (): boolean => {
-            // Check if it's possible to store an item. Safari does not allow this in private browsing mode.
-            try {
-                const key = "_storage_test";
-                sessionStorage.setItem(key, "value");
-                sessionStorage.removeItem(key);
-            } catch {
-                return false;
-            }
-
-            return true;
-        };
-
-        if (this._supportsLocalStorage == null) {
-            this._supportsLocalStorage = testSupport();
-        }
-
-        return this._supportsLocalStorage;
-    }
-
     public getNodeIdToBeSelected(): NodeId | null {
         const state = this.getStateFromStorage();
 
@@ -216,7 +122,7 @@ export default class SaveStateHandler {
 
         if (this.onSetStateFromStorage) {
             this.onSetStateFromStorage(state);
-        } else if (this.supportsLocalStorage()) {
+        } else {
             localStorage.setItem(this.getKeyName(), state);
         }
     }
@@ -225,7 +131,7 @@ export default class SaveStateHandler {
     Set initial state
     Don't handle nodes that are loaded on demand
 
-    result: must load on demand
+    result: must load on demand (boolean)
     */
     public setInitialState(state: SavedState): boolean {
         let mustLoadOnDemand = false;
@@ -296,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/selectNodeHandler.ts

@@ -64,18 +64,14 @@ export default class SelectNodeHandler {
                 return [];
             }
         } else {
-            const selectedNodes = [];
-
-            for (const id in this.selectedNodes) {
-                if (
-                    Object.prototype.hasOwnProperty.call(this.selectedNodes, id)
-                ) {
-                    const node = this.getNodeById(id);
-                    if (node && parent.isParentOf(node)) {
-                        selectedNodes.push(node);
-                    }
+            const selectedNodes: Node[] = [];
+
+            this.selectedNodes.forEach((id) => {
+                const node = this.getNodeById(id);
+                if (node && parent.isParentOf(node)) {
+                    selectedNodes.push(node);
                 }
-            }
+            });
 
             return selectedNodes;
         }