jqtree 1.8.5 → 1.8.6

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

package/src/scrollHandler/documentScrollParent.ts

@@ -1,5 +1,6 @@
 import type { ScrollParent } from "./types";
-import { getOffsetTop } from '../util'
+
+import { getOffsetTop } from "../util";
 
 type HorizontalScrollDirection = "left" | "right";
 type VerticalScrollDirection = "bottom" | "top";
@@ -24,62 +25,40 @@ 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);
-            }
+    private canScrollDown() {
+        const documentElement = document.documentElement;
 
-            if (newHorizontalScrollDirection) {
-                this.horizontalScrollTimeout = window.setTimeout(
-                    this.scrollHorizontally.bind(this),
-                    40,
-                );
-            }
-        }
+        return (
+            documentElement.scrollTop + documentElement.clientHeight <
+            this.getDocumentScrollHeight()
+        );
     }
 
-    public checkVerticalScrolling(pageY: number) {
-        const newVerticalScrollDirection =
-            this.getNewVerticalScrollDirection(pageY);
-
-        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
-            this.verticalScrollDirection = newVerticalScrollDirection;
+    private canScrollRight() {
+        const documentElement = document.documentElement;
 
-            if (this.verticalScrollTimeout != null) {
-                window.clearTimeout(this.verticalScrollTimeout);
-                this.verticalScrollTimeout = undefined;
-            }
+        return (
+            documentElement.scrollLeft + documentElement.clientWidth <
+            this.getDocumentScrollWidth()
+        );
+    }
 
-            if (newVerticalScrollDirection) {
-                this.verticalScrollTimeout = window.setTimeout(
-                    this.scrollVertically.bind(this),
-                    40,
-                );
-            }
+    private getDocumentScrollHeight() {
+        // Store the original scroll height because the scroll height can increase when the drag element is moved beyond the scroll height.
+        if (this.documentScrollHeight == null) {
+            this.documentScrollHeight = document.documentElement.scrollHeight;
         }
-    }
 
-    public getScrollLeft(): number {
-        return document.documentElement.scrollLeft;
+        return this.documentScrollHeight;
     }
 
-    public scrollToY(top: number): void {
-        const treeTop = getOffsetTop(this.treeElement);
-
-        document.documentElement.scrollTop = top + treeTop;
-    }
+    private getDocumentScrollWidth() {
+        // Store the original scroll width because the scroll width can increase when the drag element is moved beyond the scroll width.
+        if (this.documentScrollWidth == null) {
+            this.documentScrollWidth = document.documentElement.scrollWidth;
+        }
 
-    public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
-        this.documentScrollHeight = undefined;
-        this.documentScrollWidth = undefined;
+        return this.documentScrollWidth;
     }
 
     private getNewHorizontalScrollDirection(
@@ -102,46 +81,10 @@ export default class DocumentScrollParent implements ScrollParent {
         return undefined;
     }
 
-    private canScrollRight() {
-        const documentElement = document.documentElement;
-
-        return (
-            documentElement.scrollLeft + documentElement.clientWidth <
-            this.getDocumentScrollWidth()
-        );
-    }
-
-    private canScrollDown() {
-        const documentElement = document.documentElement;
-
-        return (
-            documentElement.scrollTop + documentElement.clientHeight <
-            this.getDocumentScrollHeight()
-        );
-    }
-
-    private getDocumentScrollHeight() {
-        // Store the original scroll height because the scroll height can increase when the drag element is moved beyond the scroll height.
-        if (this.documentScrollHeight == null) {
-            this.documentScrollHeight = document.documentElement.scrollHeight;
-        }
-
-        return this.documentScrollHeight;
-    }
-
-    private getDocumentScrollWidth() {
-        // Store the original scroll width because the scroll width can increase when the drag element is moved beyond the scroll width.
-        if (this.documentScrollWidth == null) {
-            this.documentScrollWidth = document.documentElement.scrollWidth;
-        }
-
-        return this.documentScrollWidth;
-    }
-
     private getNewVerticalScrollDirection(
         pageY: number,
-    ): VerticalScrollDirection | undefined {
-        const scrollTop = jQuery(document).scrollTop() || 0;
+    ): undefined | VerticalScrollDirection {
+        const scrollTop = jQuery(document).scrollTop() ?? 0;
         const distanceTop = pageY - scrollTop;
 
         if (distanceTop < 20) {
@@ -163,7 +106,7 @@ export default class DocumentScrollParent implements ScrollParent {
         }
 
         const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
-        window.scrollBy({ left: distance, top: 0, behavior: "instant" });
+        window.scrollBy({ behavior: "instant", left: distance, top: 0 });
 
         this.refreshHitAreas();
 
@@ -176,10 +119,68 @@ export default class DocumentScrollParent implements ScrollParent {
         }
 
         const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-        window.scrollBy({ left: 0, top: distance, behavior: "instant" });
+        window.scrollBy({ behavior: "instant", left: 0, top: distance });
 
         this.refreshHitAreas();
 
         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

@@ -1,6 +1,6 @@
 import { PositionInfo } from "./mouseUtils";
-import { ScrollParent } from "./scrollHandler/types";
 import createScrollParent from "./scrollHandler/createScrollParent";
+import { ScrollParent } from "./scrollHandler/types";
 
 interface ScrollHandlerParams {
     refreshHitAreas: () => void;
@@ -18,31 +18,14 @@ export default class ScrollHandler {
         this.treeElement = treeElement;
     }
 
-    public checkScrolling(positionInfo: PositionInfo): void {
-        this.checkVerticalScrolling(positionInfo);
-        this.checkHorizontalScrolling(positionInfo);
-    }
-
-    public stopScrolling() {
-        this.getScrollParent().stopScrolling();
-    }
-
-    public scrollToY(top: number): void {
-        this.getScrollParent().scrollToY(top);
-    }
-
-    public getScrollLeft(): number {
-        return this.getScrollParent().getScrollLeft();
+    private checkHorizontalScrolling(positionInfo: PositionInfo): void {
+        this.getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
     }
 
     private checkVerticalScrolling(positionInfo: PositionInfo): void {
         this.getScrollParent().checkVerticalScrolling(positionInfo.pageY);
     }
 
-    private checkHorizontalScrolling(positionInfo: PositionInfo): void {
-        this.getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
-    }
-
     private getScrollParent(): ScrollParent {
         if (!this.scrollParent) {
             this.scrollParent = createScrollParent(
@@ -53,4 +36,21 @@ 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

@@ -1,5 +1,5 @@
-import { Node } from "./node";
 import { GetNodeById } from "./jqtreeMethodTypes";
+import { Node } from "./node";
 
 interface SelectNodeHandlerParameters {
     getNodeById: GetNodeById;
@@ -16,11 +16,24 @@ export default class SelectNodeHandler {
         this.clear();
     }
 
-    public getSelectedNode(): Node | false {
+    public addToSelection(node: Node): void {
+        if (node.id != null) {
+            this.selectedNodes.add(node.id);
+        } else {
+            this.selectedSingleNode = node;
+        }
+    }
+
+    public clear(): void {
+        this.selectedNodes.clear();
+        this.selectedSingleNode = null;
+    }
+
+    public getSelectedNode(): false | Node {
         const selectedNodes = this.getSelectedNodes();
 
         if (selectedNodes.length) {
-            return selectedNodes[0] || false;
+            return selectedNodes[0] ?? false;
         } else {
             return false;
         }
@@ -78,11 +91,6 @@ export default class SelectNodeHandler {
         }
     }
 
-    public clear(): void {
-        this.selectedNodes.clear();
-        this.selectedSingleNode = null;
-    }
-
     public removeFromSelection(node: Node, includeChildren = false): void {
         if (node.id == null) {
             if (
@@ -104,12 +112,4 @@ export default class SelectNodeHandler {
             }
         }
     }
-
-    public addToSelection(node: Node): void {
-        if (node.id != null) {
-            this.selectedNodes.add(node.id);
-        } else {
-            this.selectedSingleNode = node;
-        }
-    }
 }

package/src/simple.widget.ts

@@ -3,8 +3,8 @@ const register = (widgetClass: unknown, widgetName: string): void => {
 
     const getWidgetData = (
         el: HTMLElement,
-        dataKey: string
-    ): SimpleWidget<unknown> | null => {
+        dataKey: string,
+    ): null | SimpleWidget<unknown> => {
         const widget = jQuery.data(el, dataKey) as unknown;
 
         if (widget && widget instanceof SimpleWidget) {
@@ -53,7 +53,7 @@ const register = (widgetClass: unknown, widgetName: string): void => {
     const callFunction = (
         $el: JQuery,
         functionName: string,
-        args: unknown[]
+        args: unknown[],
     ): unknown => {
         let result = null;
 
@@ -88,7 +88,8 @@ const register = (widgetClass: unknown, widgetName: string): void => {
             const functionName = argument1;
 
             if (functionName === "destroy") {
-                return destroyWidget(this);
+                destroyWidget(this);
+                return undefined;
             } else if (functionName === "get_widget_class") {
                 return widgetClass;
             } else {
@@ -101,35 +102,35 @@ const register = (widgetClass: unknown, widgetName: string): void => {
 };
 
 export default class SimpleWidget<WidgetOptions> {
-    public static register(widgetClass: unknown, widgetName: string): void {
-        register(widgetClass, widgetName);
-    }
-
     [key: string]: unknown;
 
     protected static defaults: unknown = {};
 
-    public options: WidgetOptions;
+    public $el: JQuery;
 
-    public $el: JQuery<HTMLElement>;
+    public options: WidgetOptions;
 
     constructor(el: HTMLElement, options: WidgetOptions) {
         this.$el = jQuery(el);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        const defaults = (this.constructor as any)["defaults"] as WidgetOptions;
+        const defaults = (this.constructor as any).defaults as WidgetOptions;
         this.options = { ...defaults, ...options };
     }
 
-    public destroy(): void {
-        this.deinit();
+    public static register(widgetClass: unknown, widgetName: string): void {
+        register(widgetClass, widgetName);
     }
 
-    public init(): void {
+    public deinit(): void {
         //
     }
 
-    public deinit(): void {
+    public destroy(): void {
+        this.deinit();
+    }
+
+    public init(): void {
         //
     }
 }