jqtree 1.8.11 → 1.9.0

package/src/scrollHandler/documentScrollParent.ts

@@ -1,28 +1,29 @@
-import { getOffsetTop } from "../util";
-import {
+import type {
     HorizontalScrollDirection,
-    ScrollParent,
     VerticalScrollDirection,
 } from "./scrollParent";
 
+import { getOffsetTop } from "../positionUtils";
+import { ScrollParent } from "./scrollParent";
+
 interface Params {
     refreshHitAreas: () => void;
     treeElement: HTMLElement;
 }
 
 export default class DocumentScrollParent extends ScrollParent {
-    private documentScrollHeight?: number;
-    private documentScrollWidth?: number;
-    private treeElement: HTMLElement;
+    private _documentScrollHeight?: number;
+    private _documentScrollWidth?: number;
+    private _treeElement: HTMLElement;
 
     constructor({ refreshHitAreas, treeElement }: Params) {
         super({ container: document.documentElement, refreshHitAreas });
 
-        this.treeElement = treeElement;
+        this._treeElement = treeElement;
     }
 
     public scrollToY(top: number): void {
-        const treeTop = getOffsetTop(this.treeElement);
+        const treeTop = getOffsetTop(this._treeElement);
 
         super.scrollToY(top + treeTop);
     }
@@ -30,8 +31,8 @@ export default class DocumentScrollParent extends ScrollParent {
     public stopScrolling() {
         super.stopScrolling();
 
-        this.documentScrollHeight = undefined;
-        this.documentScrollWidth = undefined;
+        this._documentScrollHeight = undefined;
+        this._documentScrollWidth = undefined;
     }
 
     protected getNewHorizontalScrollDirection(
@@ -43,7 +44,7 @@ export default class DocumentScrollParent extends ScrollParent {
         const isNearRightEdge = pageX > windowWidth - 20;
         const isNearLeftEdge = pageX - scrollLeft < 20;
 
-        if (isNearRightEdge && this.canScrollRight()) {
+        if (isNearRightEdge && this._canScrollRight()) {
             return "right";
         }
 
@@ -66,38 +67,38 @@ export default class DocumentScrollParent extends ScrollParent {
 
         const windowHeight = window.innerHeight;
 
-        if (windowHeight - (pageY - scrollTop) < 20 && this.canScrollDown()) {
+        if (windowHeight - (pageY - scrollTop) < 20 && this._canScrollDown()) {
             return "bottom";
         }
 
         return undefined;
     }
 
-    private canScrollDown() {
+    private _canScrollDown() {
         return (
             this.container.scrollTop + this.container.clientHeight <
-            this.getDocumentScrollHeight()
+            this._getDocumentScrollHeight()
         );
     }
 
-    private canScrollRight() {
+    private _canScrollRight() {
         return (
             this.container.scrollLeft + this.container.clientWidth <
-            this.getDocumentScrollWidth()
+            this._getDocumentScrollWidth()
         );
     }
 
-    private getDocumentScrollHeight() {
+    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;
+        this._documentScrollHeight ??= this.container.scrollHeight;
 
-        return this.documentScrollHeight;
+        return this._documentScrollHeight;
     }
 
-    private getDocumentScrollWidth() {
+    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;
+        this._documentScrollWidth ??= this.container.scrollWidth;
 
-        return this.documentScrollWidth;
+        return this._documentScrollWidth;
     }
 }

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/scrollParent";
 
 interface ScrollHandlerParams {
     refreshHitAreas: () => void;
@@ -8,47 +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 {
-        this.scrollParent ??= createScrollParent(
-            this.treeElement,
-            this.refreshHitAreas,
+    private _getScrollParent(): ScrollParent {
+        this._scrollParent ??= createScrollParent(
+            this._treeElement,
+            this._refreshHitAreas,
         );
 
-        return this.scrollParent;
+        return this._scrollParent;
     }
 }

package/src/selectNodeHandler.ts

@@ -1,32 +1,32 @@
-import { GetNodeById } from "./jqtreeMethodTypes";
-import { Node } from "./node";
+import type { GetNodeById } from "./jqtreeMethodTypes";
+import type { Node } from "./node";
 
 interface SelectNodeHandlerParameters {
     getNodeById: GetNodeById;
 }
 
 export default class SelectNodeHandler {
-    private getNodeById: GetNodeById;
-    private selectedNodes: Set<NodeId>;
-    private selectedSingleNode: Node | null;
+    private _getNodeById: GetNodeById;
+    private _selectedNodes: Set<NodeId>;
+    private _selectedSingleNode: Node | null;
 
     constructor({ getNodeById }: SelectNodeHandlerParameters) {
-        this.getNodeById = getNodeById;
-        this.selectedNodes = new Set<NodeId>();
+        this._getNodeById = getNodeById;
+        this._selectedNodes = new Set<NodeId>();
         this.clear();
     }
 
     public addToSelection(node: Node): void {
         if (node.id != null) {
-            this.selectedNodes.add(node.id);
+            this._selectedNodes.add(node.id);
         } else {
-            this.selectedSingleNode = node;
+            this._selectedSingleNode = node;
         }
     }
 
     public clear(): void {
-        this.selectedNodes.clear();
-        this.selectedSingleNode = null;
+        this._selectedNodes.clear();
+        this._selectedSingleNode = null;
     }
 
     public getSelectedNode(): false | Node {
@@ -40,13 +40,13 @@ export default class SelectNodeHandler {
     }
 
     public getSelectedNodes(): Node[] {
-        if (this.selectedSingleNode) {
-            return [this.selectedSingleNode];
+        if (this._selectedSingleNode) {
+            return [this._selectedSingleNode];
         } else {
             const selectedNodes: Node[] = [];
 
-            this.selectedNodes.forEach((id) => {
-                const node = this.getNodeById(id);
+            this._selectedNodes.forEach((id) => {
+                const node = this._getNodeById(id);
                 if (node) {
                     selectedNodes.push(node);
                 }
@@ -57,17 +57,17 @@ export default class SelectNodeHandler {
     }
 
     public getSelectedNodesUnder(parent: Node): Node[] {
-        if (this.selectedSingleNode) {
-            if (parent.isParentOf(this.selectedSingleNode)) {
-                return [this.selectedSingleNode];
+        if (this._selectedSingleNode) {
+            if (parent.isParentOf(this._selectedSingleNode)) {
+                return [this._selectedSingleNode];
             } else {
                 return [];
             }
         } else {
             const selectedNodes: Node[] = [];
 
-            this.selectedNodes.forEach((id) => {
-                const node = this.getNodeById(id);
+            this._selectedNodes.forEach((id) => {
+                const node = this._getNodeById(id);
                 if (node && parent.isParentOf(node)) {
                     selectedNodes.push(node);
                 }
@@ -79,9 +79,9 @@ export default class SelectNodeHandler {
 
     public isNodeSelected(node: Node): boolean {
         if (node.id != null) {
-            return this.selectedNodes.has(node.id);
-        } else if (this.selectedSingleNode) {
-            return this.selectedSingleNode.element === node.element;
+            return this._selectedNodes.has(node.id);
+        } else if (this._selectedSingleNode) {
+            return this._selectedSingleNode.element === node.element;
         } else {
             return false;
         }
@@ -90,18 +90,18 @@ export default class SelectNodeHandler {
     public removeFromSelection(node: Node, includeChildren = false): void {
         if (node.id == null) {
             if (
-                this.selectedSingleNode &&
-                node.element === this.selectedSingleNode.element
+                this._selectedSingleNode &&
+                node.element === this._selectedSingleNode.element
             ) {
-                this.selectedSingleNode = null;
+                this._selectedSingleNode = null;
             }
         } else {
-            this.selectedNodes.delete(node.id);
+            this._selectedNodes.delete(node.id);
 
             if (includeChildren) {
                 node.iterate(() => {
                     if (node.id != null) {
-                        this.selectedNodes.delete(node.id);
+                        this._selectedNodes.delete(node.id);
                     }
                     return true;
                 });