jqtree 1.8.11 → 1.9.0

package/src/mouseHandler.ts

@@ -1,10 +1,11 @@
-import { TriggerEvent } from "./jqtreeMethodTypes";
+import type { TriggerEvent } from "./jqtreeMethodTypes";
+import type { PositionInfo } from "./mouseUtils";
+import type { Node } from "./node";
+
 import {
     getPositionInfoFromMouseEvent,
     getPositionInfoFromTouch,
-    PositionInfo,
 } from "./mouseUtils";
-import { Node } from "./node";
 
 export type GetMouseDelay = () => number;
 export type GetNode = (element: HTMLElement) => Node | null;
@@ -31,30 +32,30 @@ interface MouseHandlerParams {
 }
 
 class MouseHandler {
-    private element: HTMLElement;
-    private getMouseDelay: GetMouseDelay;
-    private getNode: GetNode;
+    private _element: HTMLElement;
+    private _getMouseDelay: GetMouseDelay;
+    private _getNode: GetNode;
 
-    private isMouseDelayMet: boolean;
+    private _isMouseDelayMet: boolean;
 
-    private isMouseStarted: boolean;
+    private _isMouseStarted: boolean;
 
-    private mouseDelayTimer: null | number;
+    private _mouseDelayTimer: null | number;
 
-    private mouseDownInfo: null | PositionInfo;
-    private onClickButton: (node: Node) => void;
-    private onClickTitle: (node: Node) => void;
+    private _mouseDownInfo: null | PositionInfo;
+    private _onClickButton: (node: Node) => void;
+    private _onClickTitle: (node: Node) => void;
 
-    private onMouseCapture: MouseCapture;
+    private _onMouseCapture: MouseCapture;
 
-    private onMouseDrag: (positionInfo: PositionInfo) => void;
+    private _onMouseDrag: (positionInfo: PositionInfo) => void;
 
-    private onMouseStart: MouseStart;
+    private _onMouseStart: MouseStart;
 
-    private onMouseStop: (positionInfo: PositionInfo) => void;
+    private _onMouseStop: (positionInfo: PositionInfo) => void;
 
-    private triggerEvent: TriggerEvent;
-    private useContextMenu: boolean;
+    private _triggerEvent: TriggerEvent;
+    private _useContextMenu: boolean;
     constructor({
         element,
         getMouseDelay,
@@ -68,56 +69,56 @@ class MouseHandler {
         triggerEvent,
         useContextMenu,
     }: MouseHandlerParams) {
-        this.element = element;
-        this.getMouseDelay = getMouseDelay;
-        this.getNode = getNode;
-        this.onClickButton = onClickButton;
-        this.onClickTitle = onClickTitle;
-        this.onMouseCapture = onMouseCapture;
-        this.onMouseDrag = onMouseDrag;
-        this.onMouseStart = onMouseStart;
-        this.onMouseStop = onMouseStop;
-        this.triggerEvent = triggerEvent;
-        this.useContextMenu = useContextMenu;
-
-        element.addEventListener("click", this.handleClick);
-        element.addEventListener("dblclick", this.handleDblclick);
-        element.addEventListener("mousedown", this.mouseDown, {
+        this._element = element;
+        this._getMouseDelay = getMouseDelay;
+        this._getNode = getNode;
+        this._onClickButton = onClickButton;
+        this._onClickTitle = onClickTitle;
+        this._onMouseCapture = onMouseCapture;
+        this._onMouseDrag = onMouseDrag;
+        this._onMouseStart = onMouseStart;
+        this._onMouseStop = onMouseStop;
+        this._triggerEvent = triggerEvent;
+        this._useContextMenu = useContextMenu;
+
+        element.addEventListener("click", this._handleClick);
+        element.addEventListener("dblclick", this._handleDblclick);
+        element.addEventListener("mousedown", this._mouseDown, {
             passive: false,
         });
-        element.addEventListener("touchstart", this.touchStart, {
+        element.addEventListener("touchstart", this._touchStart, {
             passive: false,
         });
 
         if (useContextMenu) {
-            element.addEventListener("contextmenu", this.handleContextmenu);
+            element.addEventListener("contextmenu", this._handleContextmenu);
         }
 
-        this.isMouseStarted = false;
-        this.mouseDelayTimer = null;
-        this.isMouseDelayMet = false;
-        this.mouseDownInfo = null;
+        this._isMouseStarted = false;
+        this._mouseDelayTimer = null;
+        this._isMouseDelayMet = false;
+        this._mouseDownInfo = null;
     }
     public deinit(): void {
-        this.element.removeEventListener("click", this.handleClick);
-        this.element.removeEventListener("dblclick", this.handleDblclick);
+        this._element.removeEventListener("click", this._handleClick);
+        this._element.removeEventListener("dblclick", this._handleDblclick);
 
-        if (this.useContextMenu) {
-            this.element.removeEventListener(
+        if (this._useContextMenu) {
+            this._element.removeEventListener(
                 "contextmenu",
-                this.handleContextmenu,
+                this._handleContextmenu,
             );
         }
 
-        this.element.removeEventListener("mousedown", this.mouseDown);
-        this.element.removeEventListener("touchstart", this.touchStart);
-        this.removeMouseMoveEventListeners();
+        this._element.removeEventListener("mousedown", this._mouseDown);
+        this._element.removeEventListener("touchstart", this._touchStart);
+        this._removeMouseMoveEventListeners();
     }
-    private getClickTarget(element: HTMLElement): ClickTarget | null {
+    private _getClickTarget(element: HTMLElement): ClickTarget | null {
         const button = element.closest<HTMLElement>(".jqtree-toggler");
 
         if (button) {
-            const node = this.getNode(button);
+            const node = this._getNode(button);
 
             if (node) {
                 return {
@@ -130,7 +131,7 @@ class MouseHandler {
                 element.closest<HTMLElement>(".jqtree-element");
 
             if (jqTreeElement) {
-                const node = this.getNode(jqTreeElement);
+                const node = this._getNode(jqTreeElement);
                 if (node) {
                     return {
                         node,
@@ -142,12 +143,12 @@ class MouseHandler {
 
         return null;
     }
-    private handleClick = (e: MouseEvent): void => {
+    private _handleClick = (e: MouseEvent): void => {
         if (!e.target) {
             return;
         }
 
-        const clickTarget = this.getClickTarget(e.target as HTMLElement);
+        const clickTarget = this._getClickTarget(e.target as HTMLElement);
 
         if (!clickTarget) {
             return;
@@ -155,27 +156,25 @@ class MouseHandler {
 
         switch (clickTarget.type) {
             case "button":
-                this.onClickButton(clickTarget.node);
+                this._onClickButton(clickTarget.node);
 
                 e.preventDefault();
                 e.stopPropagation();
                 break;
 
             case "label": {
-                const event = this.triggerEvent("tree.click", {
+                if (this._triggerEvent("tree.click", {
                     click_event: e,
                     node: clickTarget.node,
-                });
-
-                if (!event.isDefaultPrevented()) {
-                    this.onClickTitle(clickTarget.node);
+                })) {
+                    this._onClickTitle(clickTarget.node);
                 }
                 break;
             }
         }
     };
 
-    private handleContextmenu = (e: MouseEvent) => {
+    private _handleContextmenu = (e: MouseEvent) => {
         if (!e.target) {
             return;
         }
@@ -185,12 +184,12 @@ class MouseHandler {
         );
 
         if (div) {
-            const node = this.getNode(div);
+            const node = this._getNode(div);
             if (node) {
                 e.preventDefault();
                 e.stopPropagation();
 
-                this.triggerEvent("tree.contextmenu", {
+                this._triggerEvent("tree.contextmenu", {
                     click_event: e,
                     node,
                 });
@@ -201,44 +200,44 @@ class MouseHandler {
         return null;
     };
 
-    private handleDblclick = (e: MouseEvent): void => {
+    private _handleDblclick = (e: MouseEvent): void => {
         if (!e.target) {
             return;
         }
 
-        const clickTarget = this.getClickTarget(e.target as HTMLElement);
+        const clickTarget = this._getClickTarget(e.target as HTMLElement);
 
         if (clickTarget?.type === "label") {
-            this.triggerEvent("tree.dblclick", {
+            this._triggerEvent("tree.dblclick", {
                 click_event: e,
                 node: clickTarget.node,
             });
         }
     };
 
-    private handleMouseDown(positionInfo: PositionInfo): boolean {
+    private _handleMouseDown(positionInfo: PositionInfo): boolean {
         // We may have missed mouseup (out of window)
-        if (this.isMouseStarted) {
-            this.handleMouseUp(positionInfo);
+        if (this._isMouseStarted) {
+            this._handleMouseUp(positionInfo);
         }
 
-        this.mouseDownInfo = positionInfo;
+        this._mouseDownInfo = positionInfo;
 
-        if (!this.onMouseCapture(positionInfo)) {
+        if (!this._onMouseCapture(positionInfo)) {
             return false;
         }
 
-        this.handleStartMouse();
+        this._handleStartMouse();
 
         return true;
     }
 
-    private handleMouseMove(
+    private _handleMouseMove(
         e: MouseEvent | TouchEvent,
         positionInfo: PositionInfo,
     ): void {
-        if (this.isMouseStarted) {
-            this.onMouseDrag(positionInfo);
+        if (this._isMouseStarted) {
+            this._onMouseDrag(positionInfo);
 
             if (e.cancelable) {
                 e.preventDefault();
@@ -246,99 +245,99 @@ class MouseHandler {
             return;
         }
 
-        if (!this.isMouseDelayMet) {
+        if (!this._isMouseDelayMet) {
             return;
         }
 
-        if (this.mouseDownInfo) {
-            this.isMouseStarted = this.onMouseStart(this.mouseDownInfo);
+        if (this._mouseDownInfo) {
+            this._isMouseStarted = this._onMouseStart(this._mouseDownInfo);
         }
 
-        if (this.isMouseStarted) {
-            this.onMouseDrag(positionInfo);
+        if (this._isMouseStarted) {
+            this._onMouseDrag(positionInfo);
 
             if (e.cancelable) {
                 e.preventDefault();
             }
         } else {
-            this.handleMouseUp(positionInfo);
+            this._handleMouseUp(positionInfo);
         }
     }
-    private handleMouseUp(positionInfo: PositionInfo): void {
-        this.removeMouseMoveEventListeners();
-        this.isMouseDelayMet = false;
-        this.mouseDownInfo = null;
-
-        if (this.isMouseStarted) {
-            this.isMouseStarted = false;
-            this.onMouseStop(positionInfo);
+    private _handleMouseUp(positionInfo: PositionInfo): void {
+        this._removeMouseMoveEventListeners();
+        this._isMouseDelayMet = false;
+        this._mouseDownInfo = null;
+
+        if (this._isMouseStarted) {
+            this._isMouseStarted = false;
+            this._onMouseStop(positionInfo);
         }
     }
 
-    private handleStartMouse(): void {
-        document.addEventListener("mousemove", this.mouseMove, {
+    private _handleStartMouse(): void {
+        document.addEventListener("mousemove", this._mouseMove, {
             passive: false,
         });
-        document.addEventListener("touchmove", this.touchMove, {
+        document.addEventListener("touchmove", this._touchMove, {
             passive: false,
         });
-        document.addEventListener("mouseup", this.mouseUp, { passive: false });
-        document.addEventListener("touchend", this.touchEnd, {
+        document.addEventListener("mouseup", this._mouseUp, { passive: false });
+        document.addEventListener("touchend", this._touchEnd, {
             passive: false,
         });
 
-        const mouseDelay = this.getMouseDelay();
+        const mouseDelay = this._getMouseDelay();
 
         if (mouseDelay) {
-            this.startMouseDelayTimer(mouseDelay);
+            this._startMouseDelayTimer(mouseDelay);
         } else {
-            this.isMouseDelayMet = true;
+            this._isMouseDelayMet = true;
         }
     }
 
-    private mouseDown = (e: MouseEvent): void => {
+    private _mouseDown = (e: MouseEvent): void => {
         // Left mouse button?
         if (e.button !== 0) {
             return;
         }
 
-        const result = this.handleMouseDown(getPositionInfoFromMouseEvent(e));
+        const result = this._handleMouseDown(getPositionInfoFromMouseEvent(e));
 
         if (result && e.cancelable) {
             e.preventDefault();
         }
     };
 
-    private mouseMove = (e: MouseEvent): void => {
-        this.handleMouseMove(e, getPositionInfoFromMouseEvent(e));
+    private _mouseMove = (e: MouseEvent): void => {
+        this._handleMouseMove(e, getPositionInfoFromMouseEvent(e));
     };
 
-    private mouseUp = (e: MouseEvent): void => {
-        this.handleMouseUp(getPositionInfoFromMouseEvent(e));
+    private _mouseUp = (e: MouseEvent): void => {
+        this._handleMouseUp(getPositionInfoFromMouseEvent(e));
     };
 
-    private removeMouseMoveEventListeners() {
-        document.removeEventListener("mousemove", this.mouseMove);
-        document.removeEventListener("touchmove", this.touchMove);
-        document.removeEventListener("mouseup", this.mouseUp);
-        document.removeEventListener("touchend", this.touchEnd);
+    private _removeMouseMoveEventListeners() {
+        document.removeEventListener("mousemove", this._mouseMove);
+        document.removeEventListener("touchmove", this._touchMove);
+        document.removeEventListener("mouseup", this._mouseUp);
+        document.removeEventListener("touchend", this._touchEnd);
     }
 
-    private startMouseDelayTimer(mouseDelay: number): void {
-        if (this.mouseDelayTimer) {
-            clearTimeout(this.mouseDelayTimer);
+    private _startMouseDelayTimer(mouseDelay: number): void {
+        if (this._mouseDelayTimer) {
+            clearTimeout(this._mouseDelayTimer);
         }
 
-        this.mouseDelayTimer = window.setTimeout(() => {
-            if (this.mouseDownInfo) {
-                this.isMouseDelayMet = true;
+        this._mouseDelayTimer = window.setTimeout(() => {
+            if (this._mouseDownInfo) {
+                this._isMouseDelayMet = true;
             }
         }, mouseDelay);
 
-        this.isMouseDelayMet = false;
+        this._isMouseDelayMet = false;
     }
 
-    private touchEnd = (e: TouchEvent): void => {
+    private _touchEnd = (e: TouchEvent): void => {
         if (e.touches.length > 1) {
             return;
         }
@@ -349,10 +348,10 @@ class MouseHandler {
             return;
         }
 
-        this.handleMouseUp(getPositionInfoFromTouch(touch, e));
+        this._handleMouseUp(getPositionInfoFromTouch(touch, e));
     };
 
-    private touchMove = (e: TouchEvent): void => {
+    private _touchMove = (e: TouchEvent): void => {
         if (e.touches.length > 1) {
             return;
         }
@@ -363,10 +362,10 @@ class MouseHandler {
             return;
         }
 
-        this.handleMouseMove(e, getPositionInfoFromTouch(touch, e));
+        this._handleMouseMove(e, getPositionInfoFromTouch(touch, e));
     };
 
-    private touchStart = (e: TouchEvent): void => {
+    private _touchStart = (e: TouchEvent): void => {
         if (e.touches.length > 1) {
             return;
         }
@@ -377,7 +376,7 @@ class MouseHandler {
             return;
         }
 
-        this.handleMouseDown(getPositionInfoFromTouch(touch, e));
+        this._handleMouseDown(getPositionInfoFromTouch(touch, e));
     };
 }
 

package/src/node.ts

@@ -49,12 +49,12 @@ export class Node implements INode {
         if (!this.parent) {
             return null;
         } else {
-            const node = this.createNode(nodeInfo);
+            const node = this._createNode(nodeInfo);
 
             const childIndex = this.parent.getChildIndex(this);
             this.parent.addChildAtPosition(node, childIndex + 1);
 
-            node.loadChildrenFromData(nodeInfo);
+            node._loadChildrenFromData(nodeInfo);
             return node;
         }
     }
@@ -63,12 +63,12 @@ export class Node implements INode {
         if (!this.parent) {
             return null;
         } else {
-            const node = this.createNode(nodeInfo);
+            const node = this._createNode(nodeInfo);
 
             const childIndex = this.parent.getChildIndex(this);
             this.parent.addChildAtPosition(node, childIndex);
 
-            node.loadChildrenFromData(nodeInfo);
+            node._loadChildrenFromData(nodeInfo);
             return node;
         }
     }
@@ -82,7 +82,7 @@ export class Node implements INode {
     */
     public addChild(node: Node): void {
         this.children.push(node);
-        node.setParent(this);
+        node._setParent(this);
     }
 
     /*
@@ -95,7 +95,7 @@ export class Node implements INode {
     */
     public addChildAtPosition(node: Node, index: number): void {
         this.children.splice(index, 0, node);
-        node.setParent(this);
+        node._setParent(this);
     }
 
     public addNodeToIndex(node: Node): void {
@@ -108,10 +108,10 @@ export class Node implements INode {
         if (!this.parent) {
             return null;
         } else {
-            const newParent = this.createNode(nodeInfo);
+            const newParent = this._createNode(nodeInfo);
 
             if (this.tree) {
-                newParent.setParent(this.tree);
+                newParent._setParent(this.tree);
             }
             const originalParent = this.parent;
 
@@ -126,10 +126,10 @@ export class Node implements INode {
     }
 
     public append(nodeInfo: NodeData): Node {
-        const node = this.createNode(nodeInfo);
+        const node = this._createNode(nodeInfo);
         this.addChild(node);
 
-        node.loadChildrenFromData(nodeInfo);
+        node._loadChildrenFromData(nodeInfo);
         return node;
     }
 
@@ -400,7 +400,7 @@ export class Node implements INode {
 
         const addChildren = (childrenData: NodeData[]): void => {
             for (const child of childrenData) {
-                const node = this.createNode();
+                const node = this._createNode();
                 node.initFromData(child);
                 this.addChild(node);
             }
@@ -479,7 +479,7 @@ export class Node implements INode {
         this.removeChildren();
 
         for (const childData of data) {
-            const node = this.createNode(childData);
+            const node = this._createNode(childData);
             this.addChild(node);
 
             if (isNodeRecordWithChildren(childData)) {
@@ -508,7 +508,7 @@ export class Node implements INode {
             // - Or, parent is empty
             return false;
         } else {
-            movedNode.parent.doRemoveChild(movedNode);
+            movedNode.parent._doRemoveChild(movedNode);
 
             switch (position) {
                 case "after": {
@@ -543,10 +543,10 @@ export class Node implements INode {
     }
 
     public prepend(nodeInfo: NodeData): Node {
-        const node = this.createNode(nodeInfo);
+        const node = this._createNode(nodeInfo);
         this.addChildAtPosition(node, 0);
 
-        node.loadChildrenFromData(nodeInfo);
+        node._loadChildrenFromData(nodeInfo);
         return node;
     }
 
@@ -566,7 +566,7 @@ export class Node implements INode {
         // remove children from the index
         node.removeChildren();
 
-        this.doRemoveChild(node);
+        this._doRemoveChild(node);
     }
 
     public removeChildren(): void {
@@ -624,28 +624,28 @@ export class Node implements INode {
         }
     }
 
-    private createNode(nodeData?: NodeData): Node {
-        const nodeClass = this.getNodeClass();
+    private _createNode(nodeData?: NodeData): Node {
+        const nodeClass = this._getNodeClass();
         return new nodeClass(nodeData);
     }
 
-    private doRemoveChild(node: Node): void {
+    private _doRemoveChild(node: Node): void {
         this.children.splice(this.getChildIndex(node), 1);
         this.tree?.removeNodeFromIndex(node);
     }
 
-    private getNodeClass(): typeof Node {
+    private _getNodeClass(): typeof Node {
         return this.nodeClass ?? this.tree?.nodeClass ?? Node;
     }
 
     // Load children data from nodeInfo if it has children
-    private loadChildrenFromData(nodeInfo: NodeData) {
+    private _loadChildrenFromData(nodeInfo: NodeData) {
         if (isNodeRecordWithChildren(nodeInfo) && nodeInfo.children.length) {
             this.loadFromData(nodeInfo.children);
         }
     }
 
-    private setParent(parent: Node): void {
+    private _setParent(parent: Node): void {
         this.parent = parent;
         this.tree = parent.tree;
         this.tree?.addNodeToIndex(this);

package/src/nodeElement/borderDropHint.ts

@@ -1,13 +1,13 @@
-import { DropHint } from "../dragAndDropHandler/types";
+import type { DropHint } from "../dragAndDropHandler/types";
 
 class BorderDropHint implements DropHint {
-    private hint?: HTMLElement;
+    private _hint?: HTMLElement;
 
     constructor(element: HTMLElement, scrollLeft: number) {
         const div = element.querySelector(":scope > .jqtree-element");
 
         if (!div) {
-            this.hint = undefined;
+            this._hint = undefined;
             return;
         }
 
@@ -19,13 +19,13 @@ class BorderDropHint implements DropHint {
         hint.style.width = `${width}px`;
         hint.style.height = `${height}px`;
 
-        this.hint = hint;
+        this._hint = hint;
 
-        div.append(this.hint);
+        div.append(this._hint);
     }
 
     public remove(): void {
-        this.hint?.remove();
+        this._hint?.remove();
     }
 }