jqtree 1.8.9 → 1.8.11

package/src/scrollHandler/documentScrollParent.ts

@@ -1,128 +1,43 @@
-import type { ScrollParent } from "./types";
-
 import { getOffsetTop } from "../util";
+import {
+    HorizontalScrollDirection,
+    ScrollParent,
+    VerticalScrollDirection,
+} from "./scrollParent";
 
-type HorizontalScrollDirection = "left" | "right";
 interface Params {
     refreshHitAreas: () => void;
     treeElement: HTMLElement;
 }
 
-type VerticalScrollDirection = "bottom" | "top";
-
-export default class DocumentScrollParent implements ScrollParent {
+export default class DocumentScrollParent extends ScrollParent {
     private documentScrollHeight?: number;
     private documentScrollWidth?: number;
-    private horizontalScrollDirection?: HorizontalScrollDirection;
-    private horizontalScrollTimeout?: number;
-    private refreshHitAreas: () => void;
     private treeElement: HTMLElement;
-    private verticalScrollDirection?: VerticalScrollDirection;
-    private verticalScrollTimeout?: number;
 
     constructor({ refreshHitAreas, treeElement }: Params) {
-        this.refreshHitAreas = refreshHitAreas;
-        this.treeElement = treeElement;
-    }
-
-    public checkHorizontalScrolling(pageX: number): void {
-        const newHorizontalScrollDirection =
-            this.getNewHorizontalScrollDirection(pageX);
+        super({ container: document.documentElement, refreshHitAreas });
 
-        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;
+        this.treeElement = treeElement;
     }
 
     public scrollToY(top: number): void {
         const treeTop = getOffsetTop(this.treeElement);
 
-        document.documentElement.scrollTop = top + treeTop;
+        super.scrollToY(top + treeTop);
     }
 
     public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
+        super.stopScrolling();
+
         this.documentScrollHeight = undefined;
         this.documentScrollWidth = undefined;
     }
 
-    private canScrollDown() {
-        const documentElement = document.documentElement;
-
-        return (
-            documentElement.scrollTop + documentElement.clientHeight <
-            this.getDocumentScrollHeight()
-        );
-    }
-
-    private canScrollRight() {
-        const documentElement = document.documentElement;
-
-        return (
-            documentElement.scrollLeft + documentElement.clientWidth <
-            this.getDocumentScrollWidth()
-        );
-    }
-
-    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 getNewHorizontalScrollDirection(
+    protected getNewHorizontalScrollDirection(
         pageX: number,
     ): HorizontalScrollDirection | undefined {
-        const scrollLeft = document.documentElement.scrollLeft;
+        const scrollLeft = this.container.scrollLeft;
         const windowWidth = window.innerWidth;
 
         const isNearRightEdge = pageX > windowWidth - 20;
@@ -139,10 +54,10 @@ export default class DocumentScrollParent implements ScrollParent {
         return undefined;
     }
 
-    private getNewVerticalScrollDirection(
+    protected getNewVerticalScrollDirection(
         pageY: number,
     ): undefined | VerticalScrollDirection {
-        const scrollTop = jQuery(document).scrollTop() ?? 0;
+        const scrollTop = this.container.scrollTop;
         const distanceTop = pageY - scrollTop;
 
         if (distanceTop < 20) {
@@ -158,29 +73,31 @@ export default class DocumentScrollParent implements ScrollParent {
         return undefined;
     }
 
-    private scrollHorizontally() {
-        if (!this.horizontalScrollDirection) {
-            return;
-        }
-
-        const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
-        window.scrollBy({ behavior: "instant", left: distance, top: 0 });
-
-        this.refreshHitAreas();
+    private canScrollDown() {
+        return (
+            this.container.scrollTop + this.container.clientHeight <
+            this.getDocumentScrollHeight()
+        );
+    }
 
-        setTimeout(this.scrollHorizontally.bind(this), 40);
+    private canScrollRight() {
+        return (
+            this.container.scrollLeft + this.container.clientWidth <
+            this.getDocumentScrollWidth()
+        );
     }
 
-    private scrollVertically() {
-        if (!this.verticalScrollDirection) {
-            return;
-        }
+    private getDocumentScrollHeight() {
+        // Store the original scroll height because the scroll height can increase when the drag element is moved beyond the scroll height.
+        this.documentScrollHeight ??= this.container.scrollHeight;
 
-        const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-        window.scrollBy({ behavior: "instant", left: 0, top: distance });
+        return this.documentScrollHeight;
+    }
 
-        this.refreshHitAreas();
+    private getDocumentScrollWidth() {
+        // Store the original scroll width because the scroll width can increase when the drag element is moved beyond the scroll width.
+        this.documentScrollWidth ??= this.container.scrollWidth;
 
-        setTimeout(this.scrollVertically.bind(this), 40);
+        return this.documentScrollWidth;
     }
 }

package/src/scrollHandler/scrollParent.ts

@@ -0,0 +1,117 @@
+export type HorizontalScrollDirection = "left" | "right";
+export type VerticalScrollDirection = "bottom" | "top";
+
+interface ConstructorParams {
+    container: HTMLElement;
+    refreshHitAreas: () => void;
+}
+
+export abstract class ScrollParent {
+    protected container: HTMLElement;
+    protected horizontalScrollDirection?: HorizontalScrollDirection;
+    protected horizontalScrollTimeout?: number;
+
+    protected refreshHitAreas: () => void;
+    protected verticalScrollDirection?: VerticalScrollDirection;
+    protected verticalScrollTimeout?: number;
+
+    constructor({ container, refreshHitAreas }: ConstructorParams) {
+        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.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 this.container.scrollLeft;
+    }
+
+    public scrollToY(top: number): void {
+        this.container.scrollTop = top;
+    }
+
+    public stopScrolling() {
+        this.horizontalScrollDirection = undefined;
+        this.verticalScrollDirection = undefined;
+    }
+
+    protected abstract getNewHorizontalScrollDirection(
+        pageX: number,
+    ): HorizontalScrollDirection | undefined;
+    protected abstract getNewVerticalScrollDirection(
+        pageY: number,
+    ): undefined | VerticalScrollDirection;
+
+    protected scrollHorizontally() {
+        if (!this.horizontalScrollDirection) {
+            return;
+        }
+
+        const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
+        this.container.scrollBy({
+            behavior: "instant",
+            left: distance,
+            top: 0,
+        });
+
+        this.refreshHitAreas();
+
+        setTimeout(this.scrollHorizontally.bind(this), 40);
+    }
+
+    protected scrollVertically() {
+        if (!this.verticalScrollDirection) {
+            return;
+        }
+
+        const distance = this.verticalScrollDirection === "top" ? -20 : 20;
+        this.container.scrollBy({
+            behavior: "instant",
+            left: 0,
+            top: distance,
+        });
+
+        this.refreshHitAreas();
+
+        setTimeout(this.scrollVertically.bind(this), 40);
+    }
+}

package/src/scrollHandler.ts

@@ -1,6 +1,6 @@
 import { PositionInfo } from "./mouseUtils";
 import createScrollParent from "./scrollHandler/createScrollParent";
-import { ScrollParent } from "./scrollHandler/types";
+import { ScrollParent } from "./scrollHandler/scrollParent";
 
 interface ScrollHandlerParams {
     refreshHitAreas: () => void;
@@ -44,12 +44,10 @@ export default class ScrollHandler {
     }
 
     private getScrollParent(): ScrollParent {
-        if (!this.scrollParent) {
-            this.scrollParent = createScrollParent(
-                this.treeElement,
-                this.refreshHitAreas,
-            );
-        }
+        this.scrollParent ??= createScrollParent(
+            this.treeElement,
+            this.refreshHitAreas,
+        );
 
         return this.scrollParent;
     }

package/src/simple.widget.ts

@@ -87,11 +87,9 @@ const register = (widgetClass: unknown, widgetName: string): void => {
         } else if (typeof argument1 === "string" && argument1[0] !== "_") {
             const functionName = argument1;
 
-            if (functionName === "destroy") {
+            if (argument1 === "destroy") {
                 destroyWidget(this);
                 return undefined;
-            } else if (functionName === "get_widget_class") {
-                return widgetClass;
             } else {
                 return callFunction(this, functionName, args);
             }

package/src/tree.jquery.ts

@@ -190,7 +190,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         const element =
             inputElement instanceof HTMLElement
                 ? inputElement
-                : inputElement[0];
+                : inputElement.get(0);
 
         if (!element) {
             return null;
@@ -247,9 +247,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
 
         this.options.rtl = this.getRtlOption();
 
-        if (this.options.closedIcon == null) {
-            this.options.closedIcon = this.getDefaultClosedIcon();
-        }
+        this.options.closedIcon ??= this.getDefaultClosedIcon();
 
         this.connectHandlers();
 
@@ -373,9 +371,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
                 onFinished = param2 as OnFinishOpenNode;
             }
 
-            if (slide == null) {
-                slide = this.options.slide;
-            }
+            slide ??= this.options.slide;
 
             return [slide, onFinished];
         };
@@ -703,7 +699,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
     private containsElement(element: HTMLElement): boolean {
         const node = this.getNode(element);
 
-        return node != null && node.tree === this.tree;
+        return node?.tree === this.tree;
     }
 
     private createFolderElement(node: Node) {
@@ -1005,11 +1001,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
     private isFocusOnTree(): boolean {
         const activeElement = document.activeElement;
 
-        return Boolean(
-            activeElement &&
-                activeElement.tagName === "SPAN" &&
-                this.containsElement(activeElement as HTMLElement),
-        );
+        return activeElement?.tagName === "SPAN" && this.containsElement(activeElement as HTMLElement);
     }
 
     private isSelectedNodeInSubtree(subtree: Node): boolean {

package/src/version.ts

@@ -1,3 +1,3 @@
-const version = "1.8.9";
+const version = "1.8.11";
 
 export default version;