jqtree 1.8.5 → 1.8.7

package/src/scrollHandler/documentScrollParent.ts

@@ -1,5 +1,6 @@
 import type { ScrollParent } from "./types";
-import { getOffsetTop } from '../util'
+
+import { getOffsetTop } from "../util";
 
 type HorizontalScrollDirection = "left" | "right";
 type VerticalScrollDirection = "bottom" | "top";
@@ -24,62 +25,40 @@ export default class DocumentScrollParent implements ScrollParent {
         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);
-            }
+    private canScrollDown() {
+        const documentElement = document.documentElement;
 
-            if (newHorizontalScrollDirection) {
-                this.horizontalScrollTimeout = window.setTimeout(
-                    this.scrollHorizontally.bind(this),
-                    40,
-                );
-            }
-        }
+        return (
+            documentElement.scrollTop + documentElement.clientHeight <
+            this.getDocumentScrollHeight()
+        );
     }
 
-    public checkVerticalScrolling(pageY: number) {
-        const newVerticalScrollDirection =
-            this.getNewVerticalScrollDirection(pageY);
-
-        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
-            this.verticalScrollDirection = newVerticalScrollDirection;
+    private canScrollRight() {
+        const documentElement = document.documentElement;
 
-            if (this.verticalScrollTimeout != null) {
-                window.clearTimeout(this.verticalScrollTimeout);
-                this.verticalScrollTimeout = undefined;
-            }
+        return (
+            documentElement.scrollLeft + documentElement.clientWidth <
+            this.getDocumentScrollWidth()
+        );
+    }
 
-            if (newVerticalScrollDirection) {
-                this.verticalScrollTimeout = window.setTimeout(
-                    this.scrollVertically.bind(this),
-                    40,
-                );
-            }
+    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;
         }
-    }
 
-    public getScrollLeft(): number {
-        return document.documentElement.scrollLeft;
+        return this.documentScrollHeight;
     }
 
-    public scrollToY(top: number): void {
-        const treeTop = getOffsetTop(this.treeElement);
-
-        document.documentElement.scrollTop = top + treeTop;
-    }
+    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;
+        }
 
-    public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
-        this.documentScrollHeight = undefined;
-        this.documentScrollWidth = undefined;
+        return this.documentScrollWidth;
     }
 
     private getNewHorizontalScrollDirection(
@@ -102,46 +81,10 @@ export default class DocumentScrollParent implements ScrollParent {
         return undefined;
     }
 
-    private canScrollRight() {
-        const documentElement = document.documentElement;
-
-        return (
-            documentElement.scrollLeft + documentElement.clientWidth <
-            this.getDocumentScrollWidth()
-        );
-    }
-
-    private canScrollDown() {
-        const documentElement = document.documentElement;
-
-        return (
-            documentElement.scrollTop + documentElement.clientHeight <
-            this.getDocumentScrollHeight()
-        );
-    }
-
-    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 getNewVerticalScrollDirection(
         pageY: number,
-    ): VerticalScrollDirection | undefined {
-        const scrollTop = jQuery(document).scrollTop() || 0;
+    ): undefined | VerticalScrollDirection {
+        const scrollTop = jQuery(document).scrollTop() ?? 0;
         const distanceTop = pageY - scrollTop;
 
         if (distanceTop < 20) {
@@ -163,7 +106,7 @@ export default class DocumentScrollParent implements ScrollParent {
         }
 
         const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
-        window.scrollBy({ left: distance, top: 0, behavior: "instant" });
+        window.scrollBy({ behavior: "instant", left: distance, top: 0 });
 
         this.refreshHitAreas();
 
@@ -176,10 +119,68 @@ export default class DocumentScrollParent implements ScrollParent {
         }
 
         const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-        window.scrollBy({ left: 0, top: distance, behavior: "instant" });
+        window.scrollBy({ behavior: "instant", left: 0, top: distance });
 
         this.refreshHitAreas();
 
         setTimeout(this.scrollVertically.bind(this), 40);
     }
+
+    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 document.documentElement.scrollLeft;
+    }
+
+    public scrollToY(top: number): void {
+        const treeTop = getOffsetTop(this.treeElement);
+
+        document.documentElement.scrollTop = top + treeTop;
+    }
+
+    public stopScrolling() {
+        this.horizontalScrollDirection = undefined;
+        this.verticalScrollDirection = undefined;
+        this.documentScrollHeight = undefined;
+        this.documentScrollWidth = undefined;
+    }
 }

package/src/scrollHandler.ts

@@ -1,6 +1,6 @@
 import { PositionInfo } from "./mouseUtils";
-import { ScrollParent } from "./scrollHandler/types";
 import createScrollParent from "./scrollHandler/createScrollParent";
+import { ScrollParent } from "./scrollHandler/types";
 
 interface ScrollHandlerParams {
     refreshHitAreas: () => void;
@@ -18,31 +18,14 @@ export default class ScrollHandler {
         this.treeElement = treeElement;
     }
 
-    public checkScrolling(positionInfo: PositionInfo): void {
-        this.checkVerticalScrolling(positionInfo);
-        this.checkHorizontalScrolling(positionInfo);
-    }
-
-    public stopScrolling() {
-        this.getScrollParent().stopScrolling();
-    }
-
-    public scrollToY(top: number): void {
-        this.getScrollParent().scrollToY(top);
-    }
-
-    public getScrollLeft(): number {
-        return this.getScrollParent().getScrollLeft();
+    private checkHorizontalScrolling(positionInfo: PositionInfo): void {
+        this.getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
     }
 
     private checkVerticalScrolling(positionInfo: PositionInfo): void {
         this.getScrollParent().checkVerticalScrolling(positionInfo.pageY);
     }
 
-    private checkHorizontalScrolling(positionInfo: PositionInfo): void {
-        this.getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
-    }
-
     private getScrollParent(): ScrollParent {
         if (!this.scrollParent) {
             this.scrollParent = createScrollParent(
@@ -53,4 +36,21 @@ export default class ScrollHandler {
 
         return this.scrollParent;
     }
+
+    public checkScrolling(positionInfo: PositionInfo): void {
+        this.checkVerticalScrolling(positionInfo);
+        this.checkHorizontalScrolling(positionInfo);
+    }
+
+    public getScrollLeft(): number {
+        return this.getScrollParent().getScrollLeft();
+    }
+
+    public scrollToY(top: number): void {
+        this.getScrollParent().scrollToY(top);
+    }
+
+    public stopScrolling() {
+        this.getScrollParent().stopScrolling();
+    }
 }

package/src/selectNodeHandler.ts

@@ -1,5 +1,5 @@
-import { Node } from "./node";
 import { GetNodeById } from "./jqtreeMethodTypes";
+import { Node } from "./node";
 
 interface SelectNodeHandlerParameters {
     getNodeById: GetNodeById;
@@ -16,11 +16,24 @@ export default class SelectNodeHandler {
         this.clear();
     }
 
-    public getSelectedNode(): Node | false {
+    public addToSelection(node: Node): void {
+        if (node.id != null) {
+            this.selectedNodes.add(node.id);
+        } else {
+            this.selectedSingleNode = node;
+        }
+    }
+
+    public clear(): void {
+        this.selectedNodes.clear();
+        this.selectedSingleNode = null;
+    }
+
+    public getSelectedNode(): false | Node {
         const selectedNodes = this.getSelectedNodes();
 
         if (selectedNodes.length) {
-            return selectedNodes[0] || false;
+            return selectedNodes[0] ?? false;
         } else {
             return false;
         }
@@ -78,11 +91,6 @@ export default class SelectNodeHandler {
         }
     }
 
-    public clear(): void {
-        this.selectedNodes.clear();
-        this.selectedSingleNode = null;
-    }
-
     public removeFromSelection(node: Node, includeChildren = false): void {
         if (node.id == null) {
             if (
@@ -104,12 +112,4 @@ export default class SelectNodeHandler {
             }
         }
     }
-
-    public addToSelection(node: Node): void {
-        if (node.id != null) {
-            this.selectedNodes.add(node.id);
-        } else {
-            this.selectedSingleNode = node;
-        }
-    }
 }

package/src/simple.widget.ts

@@ -3,8 +3,8 @@ const register = (widgetClass: unknown, widgetName: string): void => {
 
     const getWidgetData = (
         el: HTMLElement,
-        dataKey: string
-    ): SimpleWidget<unknown> | null => {
+        dataKey: string,
+    ): null | SimpleWidget<unknown> => {
         const widget = jQuery.data(el, dataKey) as unknown;
 
         if (widget && widget instanceof SimpleWidget) {
@@ -53,7 +53,7 @@ const register = (widgetClass: unknown, widgetName: string): void => {
     const callFunction = (
         $el: JQuery,
         functionName: string,
-        args: unknown[]
+        args: unknown[],
     ): unknown => {
         let result = null;
 
@@ -88,7 +88,8 @@ const register = (widgetClass: unknown, widgetName: string): void => {
             const functionName = argument1;
 
             if (functionName === "destroy") {
-                return destroyWidget(this);
+                destroyWidget(this);
+                return undefined;
             } else if (functionName === "get_widget_class") {
                 return widgetClass;
             } else {
@@ -101,35 +102,35 @@ const register = (widgetClass: unknown, widgetName: string): void => {
 };
 
 export default class SimpleWidget<WidgetOptions> {
-    public static register(widgetClass: unknown, widgetName: string): void {
-        register(widgetClass, widgetName);
-    }
-
     [key: string]: unknown;
 
     protected static defaults: unknown = {};
 
-    public options: WidgetOptions;
+    public $el: JQuery;
 
-    public $el: JQuery<HTMLElement>;
+    public options: WidgetOptions;
 
     constructor(el: HTMLElement, options: WidgetOptions) {
         this.$el = jQuery(el);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        const defaults = (this.constructor as any)["defaults"] as WidgetOptions;
+        const defaults = (this.constructor as any).defaults as WidgetOptions;
         this.options = { ...defaults, ...options };
     }
 
-    public destroy(): void {
-        this.deinit();
+    public static register(widgetClass: unknown, widgetName: string): void {
+        register(widgetClass, widgetName);
     }
 
-    public init(): void {
+    public deinit(): void {
         //
     }
 
-    public deinit(): void {
+    public destroy(): void {
+        this.deinit();
+    }
+
+    public init(): void {
         //
     }
 }

package/src/tree.jquery.d.ts

@@ -2,41 +2,40 @@ type NodeId = number | string;
 
 interface NodeRecord {
     [key: string]: unknown;
-    id?: NodeId;
     children?: NodeData[];
+    id?: NodeId;
 }
 
-type NodeData = string | NodeRecord;
+type NodeData = NodeRecord | string;
 
 type IterateCallback = (node: INode, level: number) => boolean;
 
 interface INode {
-    id?: NodeId;
-    name: string;
+    [key: string]: unknown;
     children: INode[];
-    element: HTMLElement;
+    element?: HTMLElement;
+    id?: NodeId;
     is_open: boolean;
-    parent: INode | null;
+    iterate(callback: IterateCallback): void;
 
-    [key: string]: unknown;
+    name: string;
 
-    iterate(callback: IterateCallback): void;
+    parent: INode | null;
 }
 
 type DataUrlFunction = (node?: Node) => JQuery.AjaxSettings;
-type DataUrl = string | JQuery.AjaxSettings | DataUrlFunction;
+type DataUrl = DataUrlFunction | JQuery.AjaxSettings | string;
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface ClickNodeEvent {
-    node: INode;
-    deselected_node?: INode | null;
     click_event: JQuery.ClickEvent;
+    deselected_node?: INode | null;
+    node: INode;
     previous_node?: INode;
 }
 
 interface SelectNodeOptions {
-    mustToggle?: boolean;
     mustSetFocus?: boolean;
+    mustToggle?: boolean;
 }
 
 interface SavedState {
@@ -45,42 +44,41 @@ interface SavedState {
 }
 
 interface IJQTreeOptions {
-    animationSpeed?: string | number;
+    animationSpeed?: number | string;
     autoEscape?: boolean;
     autoOpen?: boolean | number | string;
     buttonLeft?: boolean;
-    closedIcon?: string | HTMLElement | JQuery<HTMLElement>;
+    closedIcon?: HTMLElement | JQuery | string;
     data?: NodeData[];
     dataFilter?: (data: NodeData[]) => NodeData[];
     dataUrl?: DataUrl;
     dragAndDrop?: boolean;
-    nodeClass?: any;
     keyboardSupport?: boolean;
+    nodeClass?: any;
     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;
+    onGetStateFromStorage?: () => string;
     onIsMoveHandle?: (el: JQuery) => boolean;
     onLoadFailed?: (response: JQuery.jqXHR) => void;
     onLoading?: (isLoading: boolean, node: INode, $el: JQuery) => void;
-    onGetStateFromStorage?: () => string;
     onSetStateFromStorage?: (data: string) => void;
-    openedIcon?: string | HTMLElement | JQuery<HTMLElement>;
-    openFolderDelay?: number | false;
+    openedIcon?: HTMLElement | JQuery | string;
+    openFolderDelay?: false | number;
     rtl?: boolean;
-    selectable?: boolean;
     saveState?: boolean | string;
-    slide?: boolean;
+    selectable?: boolean;
     showEmptyFolder?: boolean;
+    slide?: boolean;
     startDndDelay?: number;
     tabIndex?: number;
     useContextMenu?: boolean;
 }
 
 interface IJQTreePlugin {
-    (): JQuery;
-    (options: IJQTreeOptions): JQuery;
+    (options?: IJQTreeOptions): JQuery;
     (
         behavior: "addNodeAfter",
         newNodeInfo: NodeData,
@@ -109,9 +107,9 @@ interface IJQTreePlugin {
     (behavior: "getNodeByName", name: string): INode | null;
     (behavior: "getNodeByNameMustExist", name: string): INode;
     (behavior: "getNodesByProperty", key: string, value: unknown): INode[];
-    (behavior: "getSelectedNode"): INode | false;
+    (behavior: "getSelectedNode"): false | INode;
     (behavior: "getSelectedNodes"): INode[];
-    (behavior: "getState"): SavedState | null;
+    (behavior: "getState"): null | SavedState;
     (behavior: "getStateFromStorage"): INode | null;
     (behavior: "getTree"): INode;
     (behavior: "getVersion"): string;
@@ -119,8 +117,8 @@ interface IJQTreePlugin {
     (behavior: "loadData", data: NodeData[], parentNode?: INode): JQuery;
     (
         behavior: "loadDataFromUrl",
-        param1?: string | null | INode,
-        param2?: INode | null | (() => void),
+        param1?: INode | null | string,
+        param2?: (() => void) | INode | null,
         param3?: () => void,
     ): JQuery;
     (behavior: "moveDown"): JQuery;