jqtree 1.8.11 → 1.9.1

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,20 +31,20 @@ export default class DocumentScrollParent extends ScrollParent {
     public stopScrolling() {
         super.stopScrolling();
 
-        this.documentScrollHeight = undefined;
-        this.documentScrollWidth = undefined;
+        this._documentScrollHeight = undefined;
+        this._documentScrollWidth = undefined;
     }
 
-    protected getNewHorizontalScrollDirection(
+    protected _getNewHorizontalScrollDirection(
         pageX: number,
     ): HorizontalScrollDirection | undefined {
-        const scrollLeft = this.container.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";
         }
 
@@ -54,10 +55,10 @@ export default class DocumentScrollParent extends ScrollParent {
         return undefined;
     }
 
-    protected getNewVerticalScrollDirection(
+    protected _getNewVerticalScrollDirection(
         pageY: number,
     ): undefined | VerticalScrollDirection {
-        const scrollTop = this.container.scrollTop;
+        const scrollTop = this._container.scrollTop;
         const distanceTop = pageY - scrollTop;
 
         if (distanceTop < 20) {
@@ -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._container.scrollTop + this._container.clientHeight <
+            this._getDocumentScrollHeight()
         );
     }
 
-    private canScrollRight() {
+    private _canScrollRight() {
         return (
-            this.container.scrollLeft + this.container.clientWidth <
-            this.getDocumentScrollWidth()
+            this._container.scrollLeft + this._container.clientWidth <
+            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/scrollParent.ts

@@ -7,33 +7,33 @@ interface ConstructorParams {
 }
 
 export abstract class ScrollParent {
-    protected container: HTMLElement;
-    protected horizontalScrollDirection?: HorizontalScrollDirection;
-    protected horizontalScrollTimeout?: number;
+    protected _container: HTMLElement;
+    protected _horizontalScrollDirection?: HorizontalScrollDirection;
+    protected _horizontalScrollTimeout?: number;
 
-    protected refreshHitAreas: () => void;
-    protected verticalScrollDirection?: VerticalScrollDirection;
-    protected verticalScrollTimeout?: number;
+    protected _refreshHitAreas: () => void;
+    protected _verticalScrollDirection?: VerticalScrollDirection;
+    protected _verticalScrollTimeout?: number;
 
     constructor({ container, refreshHitAreas }: ConstructorParams) {
-        this.container = container;
-        this.refreshHitAreas = refreshHitAreas;
+        this._container = container;
+        this._refreshHitAreas = refreshHitAreas;
     }
 
     public checkHorizontalScrolling(pageX: number): void {
         const newHorizontalScrollDirection =
-            this.getNewHorizontalScrollDirection(pageX);
+            this._getNewHorizontalScrollDirection(pageX);
 
-        if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
-            this.horizontalScrollDirection = newHorizontalScrollDirection;
+        if (this._horizontalScrollDirection !== newHorizontalScrollDirection) {
+            this._horizontalScrollDirection = newHorizontalScrollDirection;
 
-            if (this.horizontalScrollTimeout != null) {
-                window.clearTimeout(this.horizontalScrollTimeout);
+            if (this._horizontalScrollTimeout != null) {
+                window.clearTimeout(this._horizontalScrollTimeout);
             }
 
             if (newHorizontalScrollDirection) {
-                this.horizontalScrollTimeout = window.setTimeout(
-                    this.scrollHorizontally.bind(this),
+                this._horizontalScrollTimeout = window.setTimeout(
+                    this._scrollHorizontally.bind(this),
                     40,
                 );
             }
@@ -42,19 +42,19 @@ export abstract class ScrollParent {
 
     public checkVerticalScrolling(pageY: number) {
         const newVerticalScrollDirection =
-            this.getNewVerticalScrollDirection(pageY);
+            this._getNewVerticalScrollDirection(pageY);
 
-        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
-            this.verticalScrollDirection = newVerticalScrollDirection;
+        if (this._verticalScrollDirection !== newVerticalScrollDirection) {
+            this._verticalScrollDirection = newVerticalScrollDirection;
 
-            if (this.verticalScrollTimeout != null) {
-                window.clearTimeout(this.verticalScrollTimeout);
-                this.verticalScrollTimeout = undefined;
+            if (this._verticalScrollTimeout != null) {
+                window.clearTimeout(this._verticalScrollTimeout);
+                this._verticalScrollTimeout = undefined;
             }
 
             if (newVerticalScrollDirection) {
-                this.verticalScrollTimeout = window.setTimeout(
-                    this.scrollVertically.bind(this),
+                this._verticalScrollTimeout = window.setTimeout(
+                    this._scrollVertically.bind(this),
                     40,
                 );
             }
@@ -62,56 +62,56 @@ export abstract class ScrollParent {
     }
 
     public getScrollLeft(): number {
-        return this.container.scrollLeft;
+        return this._container.scrollLeft;
     }
 
     public scrollToY(top: number): void {
-        this.container.scrollTop = top;
+        this._container.scrollTop = top;
     }
 
     public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
+        this._horizontalScrollDirection = undefined;
+        this._verticalScrollDirection = undefined;
     }
 
-    protected abstract getNewHorizontalScrollDirection(
+    protected abstract _getNewHorizontalScrollDirection(
         pageX: number,
     ): HorizontalScrollDirection | undefined;
-    protected abstract getNewVerticalScrollDirection(
+    protected abstract _getNewVerticalScrollDirection(
         pageY: number,
     ): undefined | VerticalScrollDirection;
 
-    protected scrollHorizontally() {
-        if (!this.horizontalScrollDirection) {
+    protected _scrollHorizontally() {
+        if (!this._horizontalScrollDirection) {
             return;
         }
 
-        const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
-        this.container.scrollBy({
+        const distance = this._horizontalScrollDirection === "left" ? -20 : 20;
+        this._container.scrollBy({
             behavior: "instant",
             left: distance,
             top: 0,
         });
 
-        this.refreshHitAreas();
+        this._refreshHitAreas();
 
-        setTimeout(this.scrollHorizontally.bind(this), 40);
+        setTimeout(this._scrollHorizontally.bind(this), 40);
     }
 
-    protected scrollVertically() {
-        if (!this.verticalScrollDirection) {
+    protected _scrollVertically() {
+        if (!this._verticalScrollDirection) {
             return;
         }
 
-        const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-        this.container.scrollBy({
+        const distance = this._verticalScrollDirection === "top" ? -20 : 20;
+        this._container.scrollBy({
             behavior: "instant",
             left: 0,
             top: distance,
         });
 
-        this.refreshHitAreas();
+        this._refreshHitAreas();
 
-        setTimeout(this.scrollVertically.bind(this), 40);
+        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/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;
                 });

package/src/tree.jquery.d.ts

@@ -24,8 +24,8 @@ interface IJQTreeOptions {
     onCanMove?: (node: INode) => boolean;
     onCanSelectNode?: (node: INode) => boolean;
     onCreateLi?: (node: INode, el: JQuery, isSelected: boolean) => void;
-    onDragMove?: (node: INode, event: JQuery.Event | Touch) => void;
-    onDragStop?: (node: INode, event: JQuery.Event | Touch) => void;
+    onDragMove?: (node: INode, event: Event | Touch) => void;
+    onDragStop?: (node: INode, event: Event | Touch) => void;
     onGetStateFromStorage?: () => string;
     onIsMoveHandle?: (el: JQuery) => boolean;
     onLoadFailed?: (response: JQuery.jqXHR) => void;
@@ -79,6 +79,7 @@ interface IJQTreePlugin {
     (behavior: "getStateFromStorage"): INode | null;
     (behavior: "getTree"): INode;
     (behavior: "getVersion"): string;
+    (behavior: "isDragging"): boolean;
     (behavior: "isNodeSelected", node: INode): boolean;
     (behavior: "loadData", data: NodeData[], parentNode?: INode): JQuery;
     (