jqtree 1.8.10 → 1.9.0

package/src/scrollHandler/containerScrollParent.ts

@@ -1,92 +1,30 @@
-import type { ScrollParent } from "./types";
+import type {
+    HorizontalScrollDirection,
+    VerticalScrollDirection,
+} from "./scrollParent";
 
-import { getElementPosition, getOffsetTop } from '../util'
+import { getElementPosition, getOffsetTop } from "../positionUtils";
+import { ScrollParent } from "./scrollParent";
 
-type HorizontalScrollDirection = "left" | "right";
-interface Params {
-    container: HTMLElement;
-    refreshHitAreas: () => void;
-}
-
-type VerticalScrollDirection = "bottom" | "top";
-
-export default class ContainerScrollParent implements ScrollParent {
-    private container: HTMLElement;
-    private horizontalScrollDirection?: HorizontalScrollDirection;
-    private horizontalScrollTimeout?: number;
-    private refreshHitAreas: () => void;
-    private scrollParentBottom?: number;
-    private scrollParentTop?: 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;
-    }
+export default class ContainerScrollParent extends ScrollParent {
+    private _scrollParentBottom?: number;
+    private _scrollParentTop?: number;
 
     public stopScrolling() {
+        super.stopScrolling();
+
         this.horizontalScrollDirection = undefined;
         this.verticalScrollDirection = undefined;
-        this.scrollParentTop = undefined;
-        this.scrollParentBottom = undefined;
     }
 
-    private getNewHorizontalScrollDirection(
+    protected getNewHorizontalScrollDirection(
         pageX: number,
     ): HorizontalScrollDirection | undefined {
         const scrollParentOffset = getElementPosition(this.container);
+        const containerWidth = this.container.getBoundingClientRect().width;
 
-        const rightEdge = scrollParentOffset.left + this.container.clientWidth;
+        const rightEdge = scrollParentOffset.left + containerWidth;
         const leftEdge = scrollParentOffset.left;
         const isNearRightEdge = pageX > rightEdge - 20;
         const isNearLeftEdge = pageX < leftEdge + 20;
@@ -100,69 +38,34 @@ export default class ContainerScrollParent implements ScrollParent {
         return undefined;
     }
 
-    private getNewVerticalScrollDirection(
+    protected getNewVerticalScrollDirection(
         pageY: number,
     ): undefined | VerticalScrollDirection {
-        if (pageY < this.getScrollParentTop()) {
+        if (pageY < this._getScrollParentTop()) {
             return "top";
         }
 
-        if (pageY > this.getScrollParentBottom()) {
+        if (pageY > this._getScrollParentBottom()) {
             return "bottom";
         }
 
         return undefined;
     }
 
-    private getScrollParentBottom() {
-        if (this.scrollParentBottom == null) {
-            this.scrollParentBottom = this.getScrollParentTop() + this.container.clientHeight;
+    private _getScrollParentBottom() {
+        if (this._scrollParentBottom == null) {
+            const containerHeight =
+                this.container.getBoundingClientRect().height;
+            this._scrollParentBottom =
+                this._getScrollParentTop() + containerHeight;
         }
 
-        return this.scrollParentBottom;
+        return this._scrollParentBottom;
     }
 
-    private getScrollParentTop() {
-        if (this.scrollParentTop == null) {
-            this.scrollParentTop = getOffsetTop(this.container)
-        }
-
-        return this.scrollParentTop;
-    }
-
-    private 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);
-    }
-
-    private scrollVertically() {
-        if (!this.verticalScrollDirection) {
-            return;
-        }
-
-        const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-
-        this.container.scrollBy({
-            behavior: "instant",
-            left: 0,
-            top: distance,
-        });
-
-        this.refreshHitAreas();
+    private _getScrollParentTop() {
+        this._scrollParentTop ??= getOffsetTop(this.container);
 
-        setTimeout(this.scrollVertically.bind(this), 40);
+        return this._scrollParentTop;
     }
 }

package/src/scrollHandler/createScrollParent.ts

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

package/src/scrollHandler/documentScrollParent.ts

@@ -1,134 +1,50 @@
-import type { ScrollParent } from "./types";
+import type {
+    HorizontalScrollDirection,
+    VerticalScrollDirection,
+} from "./scrollParent";
 
-import { getOffsetTop } from "../util";
+import { getOffsetTop } from "../positionUtils";
+import { ScrollParent } from "./scrollParent";
 
-type HorizontalScrollDirection = "left" | "right";
 interface Params {
     refreshHitAreas: () => void;
     treeElement: HTMLElement;
 }
 
-type VerticalScrollDirection = "bottom" | "top";
-
-export default class DocumentScrollParent implements 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;
+export default class DocumentScrollParent extends ScrollParent {
+    private _documentScrollHeight?: number;
+    private _documentScrollWidth?: number;
+    private _treeElement: HTMLElement;
 
     constructor({ refreshHitAreas, treeElement }: Params) {
-        this.refreshHitAreas = refreshHitAreas;
-        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);
+        super({ container: document.documentElement, refreshHitAreas });
 
-        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);
+        const treeTop = getOffsetTop(this._treeElement);
 
-        document.documentElement.scrollTop = top + treeTop;
+        super.scrollToY(top + treeTop);
     }
 
     public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
-        this.documentScrollHeight = undefined;
-        this.documentScrollWidth = undefined;
-    }
+        super.stopScrolling();
 
-    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()
-        );
+        this._documentScrollHeight = undefined;
+        this._documentScrollWidth = undefined;
     }
 
-    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;
         const isNearLeftEdge = pageX - scrollLeft < 20;
 
-        if (isNearRightEdge && this.canScrollRight()) {
+        if (isNearRightEdge && this._canScrollRight()) {
             return "right";
         }
 
@@ -139,10 +55,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) {
@@ -151,36 +67,38 @@ export default class DocumentScrollParent implements ScrollParent {
 
         const windowHeight = window.innerHeight;
 
-        if (windowHeight - (pageY - scrollTop) < 20 && this.canScrollDown()) {
+        if (windowHeight - (pageY - scrollTop) < 20 && this._canScrollDown()) {
             return "bottom";
         }
 
         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,7 @@
-import { PositionInfo } from "./mouseUtils";
+import type { PositionInfo } from "./mouseUtils";
+import type { ScrollParent } from "./scrollHandler/scrollParent";
+
 import createScrollParent from "./scrollHandler/createScrollParent";
-import { ScrollParent } from "./scrollHandler/types";
 
 interface ScrollHandlerParams {
     refreshHitAreas: () => void;
@@ -8,49 +9,47 @@ interface ScrollHandlerParams {
 }
 
 export default class ScrollHandler {
-    private refreshHitAreas: () => void;
-    private scrollParent?: ScrollParent;
-    private treeElement: HTMLElement;
+    private _refreshHitAreas: () => void;
+    private _scrollParent?: ScrollParent;
+    private _treeElement: HTMLElement;
 
     constructor({ refreshHitAreas, treeElement }: ScrollHandlerParams) {
-        this.refreshHitAreas = refreshHitAreas;
-        this.scrollParent = undefined;
-        this.treeElement = treeElement;
+        this._refreshHitAreas = refreshHitAreas;
+        this._scrollParent = undefined;
+        this._treeElement = treeElement;
     }
 
     public checkScrolling(positionInfo: PositionInfo): void {
-        this.checkVerticalScrolling(positionInfo);
-        this.checkHorizontalScrolling(positionInfo);
+        this._checkVerticalScrolling(positionInfo);
+        this._checkHorizontalScrolling(positionInfo);
     }
 
     public getScrollLeft(): number {
-        return this.getScrollParent().getScrollLeft();
+        return this._getScrollParent().getScrollLeft();
     }
 
     public scrollToY(top: number): void {
-        this.getScrollParent().scrollToY(top);
+        this._getScrollParent().scrollToY(top);
     }
 
     public stopScrolling() {
-        this.getScrollParent().stopScrolling();
+        this._getScrollParent().stopScrolling();
     }
 
-    private checkHorizontalScrolling(positionInfo: PositionInfo): void {
-        this.getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
+    private _checkHorizontalScrolling(positionInfo: PositionInfo): void {
+        this._getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
     }
 
-    private checkVerticalScrolling(positionInfo: PositionInfo): void {
-        this.getScrollParent().checkVerticalScrolling(positionInfo.pageY);
+    private _checkVerticalScrolling(positionInfo: PositionInfo): void {
+        this._getScrollParent().checkVerticalScrolling(positionInfo.pageY);
     }
 
-    private getScrollParent(): ScrollParent {
-        if (!this.scrollParent) {
-            this.scrollParent = createScrollParent(
-                this.treeElement,
-                this.refreshHitAreas,
-            );
-        }
+    private _getScrollParent(): ScrollParent {
+        this._scrollParent ??= createScrollParent(
+            this._treeElement,
+            this._refreshHitAreas,
+        );
 
-        return this.scrollParent;
+        return this._scrollParent;
     }
 }