jqtree 1.8.5 → 1.8.7

package/src/saveStateHandler.ts

@@ -1,6 +1,3 @@
-import { isInt } from "./util";
-import { Node } from "./node";
-import { OnGetStateFromStorage, OnSetStateFromStorage } from "./jqtreeOptions";
 import {
     AddToSelection,
     GetNodeById,
@@ -10,10 +7,13 @@ import {
     RefreshElements,
     RemoveFromSelection,
 } from "./jqtreeMethodTypes";
+import { OnGetStateFromStorage, OnSetStateFromStorage } from "./jqtreeOptions";
+import { Node } from "./node";
+import { isInt } from "./util";
 
 export interface SavedState {
-    open_nodes: NodeId[];
-    selected_node: NodeId[];
+    open_nodes?: NodeId[];
+    selected_node?: NodeId[];
 }
 
 interface SaveStateHandlerParams {
@@ -30,6 +30,7 @@ interface SaveStateHandlerParams {
 }
 
 export default class SaveStateHandler {
+    private _supportsLocalStorage: boolean | null;
     private addToSelection: AddToSelection;
     private getNodeById: GetNodeById;
     private getSelectedNodes: GetSelectedNodes;
@@ -40,7 +41,6 @@ export default class SaveStateHandler {
     private refreshElements: RefreshElements;
     private removeFromSelection: RemoveFromSelection;
     private saveStateOption: boolean | string;
-    private _supportsLocalStorage: boolean | null;
 
     constructor({
         addToSelection,
@@ -66,21 +66,104 @@ export default class SaveStateHandler {
         this.saveStateOption = saveState;
     }
 
-    public saveState(): void {
-        const state = JSON.stringify(this.getState());
+    private getKeyName(): string {
+        if (typeof this.saveStateOption === "string") {
+            return this.saveStateOption;
+        } else {
+            return "tree";
+        }
+    }
 
-        if (this.onSetStateFromStorage) {
-            this.onSetStateFromStorage(state);
+    private loadFromStorage(): null | string {
+        if (this.onGetStateFromStorage) {
+            return this.onGetStateFromStorage();
         } else if (this.supportsLocalStorage()) {
-            localStorage.setItem(this.getKeyName(), state);
+            return localStorage.getItem(this.getKeyName());
+        } else {
+            return null;
         }
     }
 
-    public getStateFromStorage(): SavedState | null {
-        const jsonData = this.loadFromStorage();
+    private openInitialNodes(nodeIds: NodeId[]): boolean {
+        let mustLoadOnDemand = false;
 
-        if (jsonData) {
-            return this.parseState(jsonData) as unknown as SavedState;
+        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();
+
+        if (state?.selected_node) {
+            return state.selected_node[0] ?? null;
         } else {
             return null;
         }
@@ -118,6 +201,26 @@ export default class SaveStateHandler {
         };
     }
 
+    public getStateFromStorage(): null | SavedState {
+        const jsonData = this.loadFromStorage();
+
+        if (jsonData) {
+            return this.parseState(jsonData) as unknown as SavedState;
+        } else {
+            return null;
+        }
+    }
+
+    public saveState(): void {
+        const state = JSON.stringify(this.getState());
+
+        if (this.onSetStateFromStorage) {
+            this.onSetStateFromStorage(state);
+        } else if (this.supportsLocalStorage()) {
+            localStorage.setItem(this.getKeyName(), state);
+        }
+    }
+
     /*
     Set initial state
     Don't handle nodes that are loaded on demand
@@ -125,22 +228,19 @@ export default class SaveStateHandler {
     result: must load on demand
     */
     public setInitialState(state: SavedState): boolean {
-        if (!state) {
-            return false;
-        } else {
-            let mustLoadOnDemand = false;
+        let mustLoadOnDemand = false;
 
-            if (state.open_nodes) {
-                mustLoadOnDemand = this.openInitialNodes(state.open_nodes);
-            }
+        if (state.open_nodes) {
+            mustLoadOnDemand = this.openInitialNodes(state.open_nodes);
+        }
 
-            if (state.selected_node) {
-                this.resetSelection();
-                this.selectInitialNodes(state.selected_node);
-            }
+        this.resetSelection();
 
-            return mustLoadOnDemand;
+        if (state.selected_node) {
+            this.selectInitialNodes(state.selected_node);
         }
+
+        return mustLoadOnDemand;
     }
 
     public setInitialStateOnDemand(
@@ -151,6 +251,10 @@ export default class SaveStateHandler {
         let nodeIds = state.open_nodes;
 
         const openNodes = (): void => {
+            if (!nodeIds) {
+                return;
+            }
+
             const newNodesIds = [];
 
             for (const nodeId of nodeIds) {
@@ -171,8 +275,10 @@ export default class SaveStateHandler {
 
             nodeIds = newNodesIds;
 
-            if (this.selectInitialNodes(state.selected_node)) {
-                this.refreshElements(null);
+            if (state.selected_node) {
+                if (this.selectInitialNodes(state.selected_node)) {
+                    this.refreshElements(null);
+                }
             }
 
             if (loadingCount === 0) {
@@ -190,112 +296,4 @@ export default class SaveStateHandler {
 
         openNodes();
     }
-
-    public getNodeIdToBeSelected(): NodeId | null {
-        const state = this.getStateFromStorage();
-
-        if (state?.selected_node) {
-            return state.selected_node[0] || null;
-        } else {
-            return null;
-        }
-    }
-
-    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 && state.selected_node && isInt(state.selected_node)) {
-            // Convert to array
-            state.selected_node = [state.selected_node];
-        }
-
-        return state as unknown as SavedState;
-    }
-
-    private loadFromStorage(): string | null {
-        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 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 resetSelection(): void {
-        const selectedNodes = this.getSelectedNodes();
-
-        selectedNodes.forEach((node) => {
-            this.removeFromSelection(node);
-        });
-    }
-
-    private getKeyName(): string {
-        if (typeof this.saveStateOption === "string") {
-            return this.saveStateOption;
-        } else {
-            return "tree";
-        }
-    }
-
-    private supportsLocalStorage(): boolean {
-        const testSupport = (): boolean => {
-            // Is local storage supported?
-            if (localStorage == null) {
-                return false;
-            } else {
-                // 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 (error) {
-                    return false;
-                }
-
-                return true;
-            }
-        };
-
-        if (this._supportsLocalStorage == null) {
-            this._supportsLocalStorage = testSupport();
-        }
-
-        return this._supportsLocalStorage;
-    }
 }

package/src/scrollHandler/containerScrollParent.ts

@@ -1,4 +1,5 @@
 import type { ScrollParent } from "./types";
+
 import { getElementPosition, getOffsetTop } from '../util'
 
 type HorizontalScrollDirection = "left" | "right";
@@ -16,70 +17,14 @@ export default class ContainerScrollParent implements ScrollParent {
     private refreshHitAreas: () => void;
     private scrollParentBottom?: number;
     private scrollParentTop?: number;
-    private verticalScrollTimeout?: number;
     private verticalScrollDirection?: VerticalScrollDirection;
+    private verticalScrollTimeout?: number;
 
     constructor({ container, refreshHitAreas }: Params) {
         this.container = container;
         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 {
@@ -101,7 +46,7 @@ export default class ContainerScrollParent implements ScrollParent {
 
     private getNewVerticalScrollDirection(
         pageY: number,
-    ): VerticalScrollDirection | undefined {
+    ): undefined | VerticalScrollDirection {
         if (pageY < this.getScrollParentTop()) {
             return "top";
         }
@@ -113,6 +58,22 @@ export default class ContainerScrollParent implements ScrollParent {
         return undefined;
     }
 
+    private getScrollParentBottom() {
+        if (this.scrollParentBottom == null) {
+            this.scrollParentBottom = this.getScrollParentTop() + this.container.clientHeight;
+        }
+
+        return this.scrollParentBottom;
+    }
+
+    private getScrollParentTop() {
+        if (this.scrollParentTop == null) {
+            this.scrollParentTop = getOffsetTop(this.container)
+        }
+
+        return this.scrollParentTop;
+    }
+
     private scrollHorizontally() {
         if (!this.horizontalScrollDirection) {
             return;
@@ -121,9 +82,9 @@ export default class ContainerScrollParent implements ScrollParent {
         const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
 
         this.container.scrollBy({
+            behavior: "instant",
             left: distance,
             top: 0,
-            behavior: "instant",
         });
 
         this.refreshHitAreas();
@@ -139,9 +100,9 @@ export default class ContainerScrollParent implements ScrollParent {
         const distance = this.verticalScrollDirection === "top" ? -20 : 20;
 
         this.container.scrollBy({
+            behavior: "instant",
             left: 0,
             top: distance,
-            behavior: "instant",
         });
 
         this.refreshHitAreas();
@@ -149,19 +110,59 @@ export default class ContainerScrollParent implements ScrollParent {
         setTimeout(this.scrollVertically.bind(this), 40);
     }
 
-    private getScrollParentTop() {
-        if (this.scrollParentTop == null) {
-            this.scrollParentTop = getOffsetTop(this.container)
-        }
+    public checkHorizontalScrolling(pageX: number): void {
+        const newHorizontalScrollDirection =
+            this.getNewHorizontalScrollDirection(pageX);
 
-        return this.scrollParentTop;
+        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,
+                );
+            }
+        }
     }
 
-    private getScrollParentBottom() {
-        if (this.scrollParentBottom == null) {
-            this.scrollParentBottom = this.getScrollParentTop() + this.container.clientHeight;
+    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,
+                );
+            }
         }
+    }
 
-        return this.scrollParentBottom;
+    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/createScrollParent.ts

@@ -1,4 +1,5 @@
 import type { ScrollParent } from "./types";
+
 import ContainerScrollParent from "./containerScrollParent";
 import DocumentScrollParent from "./documentScrollParent";