jqtree 1.8.11 → 1.9.1

package/src/tree.jquery.ts

@@ -1,19 +1,22 @@
-import DataLoader, { HandleFinishedLoading } from "./dataLoader";
+import type { HandleFinishedLoading } from "./dataLoader";
+import type { OnFinishOpenNode } from "./jqtreeMethodTypes";
+import type { JQTreeOptions } from "./jqtreeOptions";
+import type { PositionInfo } from "./mouseUtils";
+import type { Position } from "./node";
+import type { SavedState } from "./saveStateHandler";
+
+import DataLoader from "./dataLoader";
 import { DragAndDropHandler } from "./dragAndDropHandler";
 import ElementsRenderer from "./elementsRenderer";
-import { OnFinishOpenNode } from "./jqtreeMethodTypes";
-import { JQTreeOptions } from "./jqtreeOptions";
 import KeyHandler from "./keyHandler";
 import MouseHandler from "./mouseHandler";
-import { PositionInfo } from "./mouseUtils";
-import { Node, Position } from "./node";
+import { Node } from "./node";
 import NodeElement from "./nodeElement";
 import FolderElement from "./nodeElement/folderElement";
-import SaveStateHandler, { SavedState } from "./saveStateHandler";
+import { getOffsetTop } from "./positionUtils";
+import SaveStateHandler from "./saveStateHandler";
 import ScrollHandler from "./scrollHandler";
 import SelectNodeHandler from "./selectNodeHandler";
-import SimpleWidget from "./simple.widget";
-import { getOffsetTop, isFunction } from "./util";
 import __version__ from "./version";
 
 interface SelectNodeOptions {
@@ -21,61 +24,70 @@ interface SelectNodeOptions {
     mustToggle?: boolean;
 }
 
+const defaults: JQTreeOptions = {
+    animationSpeed: "fast",
+    autoEscape: true,
+    autoOpen: false, // true / false / int (open n levels starting at 0)
+    buttonLeft: true,
+    // The symbol to use for a closed node - ► BLACK RIGHT-POINTING POINTER
+    // http://www.fileformat.info/info/unicode/char/25ba/index.htm
+    closedIcon: undefined,
+    data: undefined,
+    dataFilter: undefined,
+    dataUrl: undefined,
+    dragAndDrop: false,
+    keyboardSupport: true,
+    nodeClass: Node,
+    onCanMove: undefined, // Can this node be moved?
+    onCanMoveTo: undefined, // Can this node be moved to this position? function(moved_node, target_node, position)
+    onCanSelectNode: undefined,
+    onCreateLi: undefined,
+    onDragMove: undefined,
+    onDragStop: undefined,
+    onGetStateFromStorage: undefined,
+    onIsMoveHandle: undefined,
+    onLoadFailed: undefined,
+    onLoading: undefined,
+    onSetStateFromStorage: undefined,
+    openedIcon: "▼",
+    openFolderDelay: 500, // The delay for opening a folder during drag and drop; the value is in milliseconds
+    // The symbol to use for an open node - ▼ BLACK DOWN-POINTING TRIANGLE
+    // http://www.fileformat.info/info/unicode/char/25bc/index.htm
+    rtl: undefined, // right-to-left support; true / false (default)
+    saveState: false, // true / false / string (cookie name)
+    selectable: true,
+    showEmptyFolder: false,
+    slide: true, // must display slide animation?
+    startDndDelay: 300, // The delay for starting dnd (in milliseconds)
+    tabIndex: 0,
+    useContextMenu: true,
+};
+
 const NODE_PARAM_IS_EMPTY = "Node parameter is empty";
 const PARAM_IS_EMPTY = "Parameter is empty: ";
 
-export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
-    protected static defaults: JQTreeOptions = {
-        animationSpeed: "fast",
-        autoEscape: true,
-        autoOpen: false, // true / false / int (open n levels starting at 0)
-        buttonLeft: true,
-        // The symbol to use for a closed node - ► BLACK RIGHT-POINTING POINTER
-        // http://www.fileformat.info/info/unicode/char/25ba/index.htm
-        closedIcon: undefined,
-        data: undefined,
-        dataFilter: undefined,
-        dataUrl: undefined,
-        dragAndDrop: false,
-        keyboardSupport: true,
-        nodeClass: Node,
-        onCanMove: undefined, // Can this node be moved?
-        onCanMoveTo: undefined, // Can this node be moved to this position? function(moved_node, target_node, position)
-        onCanSelectNode: undefined,
-        onCreateLi: undefined,
-        onDragMove: undefined,
-        onDragStop: undefined,
-        onGetStateFromStorage: undefined,
-        onIsMoveHandle: undefined,
-        onLoadFailed: undefined,
-        onLoading: undefined,
-        onSetStateFromStorage: undefined,
-        openedIcon: "&#x25bc;",
-        openFolderDelay: 500, // The delay for opening a folder during drag and drop; the value is in milliseconds
-        // The symbol to use for an open node - ▼ BLACK DOWN-POINTING TRIANGLE
-        // http://www.fileformat.info/info/unicode/char/25bc/index.htm
-        rtl: undefined, // right-to-left support; true / false (default)
-        saveState: false, // true / false / string (cookie name)
-        selectable: true,
-        showEmptyFolder: false,
-        slide: true, // must display slide animation?
-        startDndDelay: 300, // The delay for starting dnd (in milliseconds)
-        tabIndex: 0,
-        useContextMenu: true,
-    };
-
-    private dataLoader: DataLoader;
-    private dndHandler: DragAndDropHandler;
-    private element: JQuery;
-
-    private isInitialized: boolean;
-    private keyHandler: KeyHandler;
-    private mouseHandler: MouseHandler;
-    private renderer: ElementsRenderer;
-    private saveStateHandler: SaveStateHandler;
-    private scrollHandler: ScrollHandler;
-    private selectNodeHandler: SelectNodeHandler;
-    private tree: Node;
+export class JqTreeWidget {
+    [key: string]: unknown;
+
+    private _dataLoader: DataLoader;
+    private _dndHandler: DragAndDropHandler;
+    private _element: JQuery;
+    private _htmlElement: HTMLElement;
+    private _isInitialized: boolean;
+    private _keyHandler: KeyHandler;
+    private _mouseHandler: MouseHandler;
+    private _options: JQTreeOptions;
+    private _renderer: ElementsRenderer;
+    private _saveStateHandler: SaveStateHandler;
+    private _scrollHandler: ScrollHandler;
+    private _selectNodeHandler: SelectNodeHandler;
+    private _tree: Node;
+
+    constructor(el: HTMLElement, options: Partial<JQTreeOptions>) {
+        this._htmlElement = el;
+        this._element = jQuery(el);
+        this._options = { ...defaults, ...options };
+    }
 
     public addNodeAfter(
         newNodeInfo: NodeData,
@@ -84,7 +96,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         const newNode = existingNode.addAfter(newNodeInfo);
 
         if (newNode) {
-            this.refreshElements(existingNode.parent);
+            this._refreshElements(existingNode.parent);
         }
 
         return newNode;
@@ -101,7 +113,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         const newNode = existingNode.addBefore(newNodeInfo);
 
         if (newNode) {
-            this.refreshElements(existingNode.parent);
+            this._refreshElements(existingNode.parent);
         }
 
         return newNode;
@@ -118,7 +130,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         const newNode = existingNode.addParent(newNodeInfo);
 
         if (newNode) {
-            this.refreshElements(newNode.parent);
+            this._refreshElements(newNode.parent);
         }
 
         return newNode;
@@ -129,22 +141,22 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error(NODE_PARAM_IS_EMPTY);
         }
 
-        this.selectNodeHandler.addToSelection(node);
-        this.openParents(node);
+        this._selectNodeHandler.addToSelection(node);
+        this._openParents(node);
 
-        this.getNodeElementForNode(node).select(mustSetFocus ?? true);
+        this._getNodeElementForNode(node).select(mustSetFocus ?? true);
 
-        this.saveState();
+        this._saveState();
 
-        return this.element;
+        return this._element;
     }
 
     public appendNode(newNodeInfo: NodeData, parentNodeParam?: Node): Node {
-        const parentNode = parentNodeParam ?? this.tree;
+        const parentNode = parentNodeParam ?? this._tree;
 
         const node = parentNode.append(newNodeInfo);
 
-        this.refreshElements(parentNode);
+        this._refreshElements(parentNode);
 
         return node;
     }
@@ -154,34 +166,36 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error(NODE_PARAM_IS_EMPTY);
         }
 
-        const slide = slideParam ?? this.options.slide;
+        const slide = slideParam ?? this._options.slide;
 
         if (node.isFolder() || node.isEmptyFolder) {
-            this.createFolderElement(node).close(
+            this._createFolderElement(node).close(
                 slide,
-                this.options.animationSpeed,
+                this._options.animationSpeed,
             );
 
-            this.saveState();
+            this._saveState();
         }
 
-        return this.element;
+        return this._element;
     }
 
     public deinit(): void {
-        this.element.empty();
-        this.element.off();
+        this._htmlElement.textContent = "";
+        this._element.off();
 
-        this.keyHandler.deinit();
-        this.mouseHandler.deinit();
+        this._keyHandler.deinit();
+        this._mouseHandler.deinit();
 
-        this.tree = new Node({}, true);
+        this._tree = new Node({}, true);
+    }
 
-        super.deinit();
+    public destroy(): void {
+        this.deinit();
     }
 
     public getNodeByCallback(callback: (node: Node) => boolean): Node | null {
-        return this.tree.getNodeByCallback(callback);
+        return this._tree.getNodeByCallback(callback);
     }
 
     public getNodeByHtmlElement(
@@ -196,43 +210,43 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             return null;
         }
 
-        return this.getNode(element);
+        return this._getNode(element);
     }
 
     public getNodeById(nodeId: NodeId): Node | null {
-        return this.tree.getNodeById(nodeId);
+        return this._tree.getNodeById(nodeId);
     }
 
     public getNodeByName(name: string): Node | null {
-        return this.tree.getNodeByName(name);
+        return this._tree.getNodeByName(name);
     }
 
     public getNodeByNameMustExist(name: string): Node {
-        return this.tree.getNodeByNameMustExist(name);
+        return this._tree.getNodeByNameMustExist(name);
     }
 
     public getNodesByProperty(key: string, value: unknown): Node[] {
-        return this.tree.getNodesByProperty(key, value);
+        return this._tree.getNodesByProperty(key, value);
     }
 
     public getSelectedNode(): false | Node {
-        return this.selectNodeHandler.getSelectedNode();
+        return this._selectNodeHandler.getSelectedNode();
     }
 
     public getSelectedNodes(): Node[] {
-        return this.selectNodeHandler.getSelectedNodes();
+        return this._selectNodeHandler.getSelectedNodes();
     }
 
     public getState(): null | SavedState {
-        return this.saveStateHandler.getState();
+        return this._saveStateHandler.getState();
     }
 
     public getStateFromStorage(): null | SavedState {
-        return this.saveStateHandler.getStateFromStorage();
+        return this._saveStateHandler.getStateFromStorage();
     }
 
     public getTree(): Node {
-        return this.tree;
+        return this._tree;
     }
 
     public getVersion(): string {
@@ -240,22 +254,23 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
     }
 
     public init(): void {
-        super.init();
+        const htmlElement = this._element.get(0) as HTMLElement;
+        this._htmlElement = htmlElement;
+        this._isInitialized = false;
 
-        this.element = this.$el;
-        this.isInitialized = false;
+        this._options.dataUrl ??= this._element.data("url");
 
-        this.options.rtl = this.getRtlOption();
+        const dataRtl = this._element.data("rtl") as unknown;
+        this._options.rtl ??= dataRtl === '' ? true : Boolean(dataRtl);
 
-        this.options.closedIcon ??= this.getDefaultClosedIcon();
+        this._options.closedIcon ??= this._getDefaultClosedIcon();
 
-        this.connectHandlers();
-
-        this.initData();
+        this._connectHandlers();
+        this._initData();
     }
 
     public isDragging(): boolean {
-        return this.dndHandler.isDragging;
+        return this._dndHandler.isDragging;
     }
 
     public isNodeSelected(node?: Node): boolean {
@@ -263,12 +278,12 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error(NODE_PARAM_IS_EMPTY);
         }
 
-        return this.selectNodeHandler.isNodeSelected(node);
+        return this._selectNodeHandler.isNodeSelected(node);
     }
 
     public loadData(data: NodeData[], parentNode: Node | null): JQuery {
-        this.doLoadData(data, parentNode);
-        return this.element;
+        this._doLoadData(data, parentNode);
+        return this._element;
     }
 
     /*
@@ -292,30 +307,30 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
     ): JQuery {
         if (typeof param1 === "string") {
             // first parameter is url
-            this.doLoadDataFromUrl(
+            this._doLoadDataFromUrl(
                 param1,
                 param2 as Node | null,
                 param3 ?? null,
             );
         } else {
             // first parameter is not url
-            this.doLoadDataFromUrl(
+            this._doLoadDataFromUrl(
                 null,
                 param1,
                 param2 as HandleFinishedLoading | null,
             );
         }
 
-        return this.element;
+        return this._element;
     }
 
     public moveDown(): JQuery {
         const selectedNode = this.getSelectedNode();
         if (selectedNode) {
-            this.keyHandler.moveDown(selectedNode);
+            this._keyHandler.moveDown(selectedNode);
         }
 
-        return this.element;
+        return this._element;
     }
 
     public moveNode(
@@ -335,19 +350,19 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error(PARAM_IS_EMPTY + "position");
         }
 
-        this.tree.moveNode(node, targetNode, position);
-        this.refreshElements(null);
+        this._tree.moveNode(node, targetNode, position);
+        this._refreshElements(null);
 
-        return this.element;
+        return this._element;
     }
 
     public moveUp(): JQuery {
         const selectedNode = this.getSelectedNode();
         if (selectedNode) {
-            this.keyHandler.moveUp(selectedNode);
+            this._keyHandler.moveUp(selectedNode);
         }
 
-        return this.element;
+        return this._element;
     }
 
     public openNode(
@@ -363,48 +378,43 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             let onFinished: null | OnFinishOpenNode;
             let slide: boolean | null;
 
-            if (isFunction(param1)) {
-                onFinished = param1 as OnFinishOpenNode;
+            if (typeof param1 === "function") {
+                onFinished = param1;
                 slide = null;
             } else {
                 slide = param1 as boolean;
                 onFinished = param2 as OnFinishOpenNode;
             }
 
-            slide ??= this.options.slide;
+            slide ??= this._options.slide;
 
             return [slide, onFinished];
         };
 
         const [slide, onFinished] = parseParams();
 
-        this.openNodeInternal(node, slide, onFinished);
-        return this.element;
+        this._openNodeInternal(node, slide, onFinished);
+        return this._element;
     }
 
     public prependNode(newNodeInfo: NodeData, parentNodeParam?: Node): Node {
-        const parentNode = parentNodeParam ?? this.tree;
+        const parentNode = parentNodeParam ?? this._tree;
 
         const node = parentNode.prepend(newNodeInfo);
 
-        this.refreshElements(parentNode);
+        this._refreshElements(parentNode);
 
         return node;
     }
 
     public refresh(): JQuery {
-        this.refreshElements(null);
-        return this.element;
-    }
-
-    public refreshHitAreas(): JQuery {
-        this.dndHandler.refresh();
-        return this.element;
+        this._refreshElements(null);
+        return this._element;
     }
 
     public reload(onFinished: HandleFinishedLoading | null): JQuery {
-        this.doLoadDataFromUrl(null, null, onFinished);
-        return this.element;
+        this._doLoadDataFromUrl(null, null, onFinished);
+        return this._element;
     }
 
     public removeFromSelection(node?: Node): JQuery {
@@ -412,12 +422,12 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error(NODE_PARAM_IS_EMPTY);
         }
 
-        this.selectNodeHandler.removeFromSelection(node);
+        this._selectNodeHandler.removeFromSelection(node);
 
-        this.getNodeElementForNode(node).deselect();
-        this.saveState();
+        this._getNodeElementForNode(node).deselect();
+        this._saveState();
 
-        return this.element;
+        return this._element;
     }
 
     public removeNode(node?: Node): JQuery {
@@ -429,13 +439,13 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error("Node has no parent");
         }
 
-        this.selectNodeHandler.removeFromSelection(node, true); // including children
+        this._selectNodeHandler.removeFromSelection(node, true); // including children
 
         const parent = node.parent;
         node.remove();
-        this.refreshElements(parent);
+        this._refreshElements(parent);
 
-        return this.element;
+        return this._element;
     }
 
     public scrollToNode(node?: Node): JQuery {
@@ -444,38 +454,38 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
 
         if (!node.element) {
-            return this.element;
+            return this._element;
         }
 
         const top =
             getOffsetTop(node.element) -
-            getOffsetTop(this.$el.get(0) as HTMLElement);
+            getOffsetTop(this._htmlElement);
 
-        this.scrollHandler.scrollToY(top);
+        this._scrollHandler.scrollToY(top);
 
-        return this.element;
+        return this._element;
     }
 
     public selectNode(
         node: Node | null,
         optionsParam?: SelectNodeOptions,
     ): JQuery {
-        this.doSelectNode(node, optionsParam);
-        return this.element;
+        this._doSelectNode(node, optionsParam);
+        return this._element;
     }
 
     public setOption(option: string, value: unknown): JQuery {
-        (this.options as unknown as Record<string, unknown>)[option] = value;
-        return this.element;
+        (this._options as unknown as Record<string, unknown>)[option] = value;
+        return this._element;
     }
 
     public setState(state?: SavedState): JQuery {
         if (state) {
-            this.saveStateHandler.setInitialState(state);
-            this.refreshElements(null);
+            this._saveStateHandler.setInitialState(state);
+            this._refreshElements(null);
         }
 
-        return this.element;
+        return this._element;
     }
 
     public toggle(node?: Node, slideParam: boolean | null = null): JQuery {
@@ -483,7 +493,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             throw Error(NODE_PARAM_IS_EMPTY);
         }
 
-        const slide = slideParam ?? this.options.slide;
+        const slide = slideParam ?? this._options.slide;
 
         if (node.is_open) {
             this.closeNode(node, slide);
@@ -491,11 +501,11 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             this.openNode(node, slide);
         }
 
-        return this.element;
+        return this._element;
     }
 
     public toJson(): string {
-        return JSON.stringify(this.tree.getData());
+        return JSON.stringify(this._tree.getData());
     }
 
     public updateNode(node?: Node, data?: NodeData): JQuery {
@@ -504,20 +514,20 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
 
         if (!data) {
-            return this.element;
+            return this._element;
         }
 
         const idIsChanged =
             typeof data === "object" && data.id && data.id !== node.id;
 
         if (idIsChanged) {
-            this.tree.removeNodeFromIndex(node);
+            this._tree.removeNodeFromIndex(node);
         }
 
         node.setData(data);
 
         if (idIsChanged) {
-            this.tree.addNodeToIndex(node);
+            this._tree.addNodeToIndex(node);
         }
 
         if (
@@ -528,16 +538,16 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             node.removeChildren();
 
             if (data.children.length) {
-                node.loadFromData(data.children as Node[]);
+                node.loadFromData(data.children);
             }
         }
 
-        this.refreshElements(node);
+        this._refreshElements(node);
 
-        return this.element;
+        return this._element;
     }
 
-    private connectHandlers() {
+    private _connectHandlers() {
         const {
             autoEscape,
             buttonLeft,
@@ -562,23 +572,21 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             showEmptyFolder,
             slide,
             tabIndex,
-        } = this.options;
+        } = this._options;
 
         const closeNode = this.closeNode.bind(this);
-        const getNodeElement = this.getNodeElement.bind(this);
-        const getNodeElementForNode = this.getNodeElementForNode.bind(this);
+        const getNodeElement = this._getNodeElement.bind(this);
+        const getNodeElementForNode = this._getNodeElementForNode.bind(this);
         const getNodeById = this.getNodeById.bind(this);
         const getSelectedNode = this.getSelectedNode.bind(this);
         const getTree = this.getTree.bind(this);
-        const isFocusOnTree = this.isFocusOnTree.bind(this);
+        const isFocusOnTree = this._isFocusOnTree.bind(this);
         const loadData = this.loadData.bind(this);
-        const openNode = this.openNodeInternal.bind(this);
-        const refreshElements = this.refreshElements.bind(this);
-        const refreshHitAreas = this.refreshHitAreas.bind(this);
+        const openNode = this._openNodeInternal.bind(this);
+        const refreshElements = this._refreshElements.bind(this);
         const selectNode = this.selectNode.bind(this);
-        const $treeElement = this.element;
-        const treeElement = this.element.get(0) as HTMLElement;
-        const triggerEvent = this.triggerEvent.bind(this);
+        const treeElement = this._htmlElement;
+        const triggerEvent = this._triggerEvent.bind(this);
 
         const selectNodeHandler = new SelectNodeHandler({
             getNodeById,
@@ -592,7 +600,11 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             selectNodeHandler.isNodeSelected.bind(selectNodeHandler);
         const removeFromSelection =
             selectNodeHandler.removeFromSelection.bind(selectNodeHandler);
-        const getMouseDelay = () => this.options.startDndDelay ?? 0;
+        const getMouseDelay = () => this._options.startDndDelay ?? 0;
+
+        const refreshHitAreas = () => {
+            dndHandler.refresh();
+        }
 
         const dataLoader = new DataLoader({
             dataFilter,
@@ -652,12 +664,12 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         });
 
         const renderer = new ElementsRenderer({
-            $element: $treeElement,
             autoEscape,
             buttonLeft,
             closedIcon,
             dragAndDrop,
             getTree,
+            htmlElement: treeElement,
             isNodeSelected,
             onCreateLi,
             openedIcon,
@@ -666,51 +678,44 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             tabIndex,
         });
 
-        const getNode = this.getNode.bind(this);
-        const onMouseCapture = this.mouseCapture.bind(this);
-        const onMouseDrag = this.mouseDrag.bind(this);
-        const onMouseStart = this.mouseStart.bind(this);
-        const onMouseStop = this.mouseStop.bind(this);
+        const getNode = this._getNode.bind(this);
+        const onMouseCapture = this._mouseCapture.bind(this);
+        const onMouseDrag = this._mouseDrag.bind(this);
+        const onMouseStart = this._mouseStart.bind(this);
+        const onMouseStop = this._mouseStop.bind(this);
 
         const mouseHandler = new MouseHandler({
             element: treeElement,
             getMouseDelay,
             getNode,
             onClickButton: this.toggle.bind(this),
-            onClickTitle: this.doSelectNode.bind(this),
+            onClickTitle: this._doSelectNode.bind(this),
             onMouseCapture,
             onMouseDrag,
             onMouseStart,
             onMouseStop,
             triggerEvent,
-            useContextMenu: this.options.useContextMenu,
+            useContextMenu: this._options.useContextMenu,
         });
 
-        this.dataLoader = dataLoader;
-        this.dndHandler = dndHandler;
-        this.keyHandler = keyHandler;
-        this.mouseHandler = mouseHandler;
-        this.renderer = renderer;
-        this.saveStateHandler = saveStateHandler;
-        this.scrollHandler = scrollHandler;
-        this.selectNodeHandler = selectNodeHandler;
+        this._dataLoader = dataLoader;
+        this._dndHandler = dndHandler;
+        this._keyHandler = keyHandler;
+        this._mouseHandler = mouseHandler;
+        this._renderer = renderer;
+        this._saveStateHandler = saveStateHandler;
+        this._scrollHandler = scrollHandler;
+        this._selectNodeHandler = selectNodeHandler;
     }
 
-    private containsElement(element: HTMLElement): boolean {
-        const node = this.getNode(element);
-
-        return node?.tree === this.tree;
-    }
-
-    private createFolderElement(node: Node) {
-        const closedIconElement = this.renderer.closedIconElement;
-        const getScrollLeft = this.scrollHandler.getScrollLeft.bind(
-            this.scrollHandler,
+    private _createFolderElement(node: Node) {
+        const closedIconElement = this._renderer.closedIconElement;
+        const getScrollLeft = this._scrollHandler.getScrollLeft.bind(
+            this._scrollHandler,
         );
-        const openedIconElement = this.renderer.openedIconElement;
-        const tabIndex = this.options.tabIndex;
-        const treeElement = this.element.get(0) as HTMLElement;
-        const triggerEvent = this.triggerEvent.bind(this);
+        const openedIconElement = this._renderer.openedIconElement;
+        const tabIndex = this._options.tabIndex;
+        const triggerEvent = this._triggerEvent.bind(this);
 
         return new FolderElement({
             closedIconElement,
@@ -718,84 +723,83 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             node,
             openedIconElement,
             tabIndex,
-            treeElement,
+            treeElement: this._htmlElement,
             triggerEvent,
         });
     }
 
-    private createNodeElement(node: Node) {
-        const getScrollLeft = this.scrollHandler.getScrollLeft.bind(
-            this.scrollHandler,
+    private _createNodeElement(node: Node) {
+        const getScrollLeft = this._scrollHandler.getScrollLeft.bind(
+            this._scrollHandler,
         );
-        const tabIndex = this.options.tabIndex;
-        const treeElement = this.element.get(0) as HTMLElement;
+        const tabIndex = this._options.tabIndex;
 
         return new NodeElement({
             getScrollLeft,
             node,
             tabIndex,
-            treeElement,
+            treeElement: this._htmlElement
         });
     }
 
-    private deselectCurrentNode(): void {
+    private _deselectCurrentNode(): void {
         const node = this.getSelectedNode();
         if (node) {
             this.removeFromSelection(node);
         }
     }
 
-    private deselectNodes(parentNode: Node): void {
+    private _deselectNodes(parentNode: Node): void {
         const selectedNodesUnderParent =
-            this.selectNodeHandler.getSelectedNodesUnder(parentNode);
+            this._selectNodeHandler.getSelectedNodesUnder(parentNode);
         for (const n of selectedNodesUnderParent) {
-            this.selectNodeHandler.removeFromSelection(n);
+            this._selectNodeHandler.removeFromSelection(n);
         }
     }
 
-    private doLoadData(data: NodeData[] | null, parentNode: Node | null): void {
+    private _doLoadData(data: NodeData[] | null, parentNode: Node | null): void {
         if (data) {
             if (parentNode) {
-                this.deselectNodes(parentNode);
-                this.loadSubtree(data, parentNode);
+                this._deselectNodes(parentNode);
+                this._loadSubtree(data, parentNode);
             } else {
-                this.initTree(data);
+                this._initTree(data);
             }
 
             if (this.isDragging()) {
-                this.dndHandler.refresh();
+                this._dndHandler.refresh();
             }
         }
 
-        this.triggerEvent("tree.load_data", {
+        this._triggerEvent("tree.load_data", {
             parent_node: parentNode,
             tree_data: data,
         });
     }
 
-    private doLoadDataFromUrl(
+    private _doLoadDataFromUrl(
         urlInfoParam: JQuery.AjaxSettings | null | string,
         parentNode: Node | null,
         onFinished: HandleFinishedLoading | null,
     ): void {
-        const urlInfo = urlInfoParam ?? this.getDataUrlInfo(parentNode);
+        const urlInfo = urlInfoParam ?? this._getDataUrlInfo(parentNode);
 
-        this.dataLoader.loadFromUrl(urlInfo, parentNode, onFinished);
+        this._dataLoader.loadFromUrl(urlInfo, parentNode, onFinished);
     }
 
-    private doSelectNode(
+    private _doSelectNode(
         node: Node | null,
         optionsParam?: SelectNodeOptions,
     ): void {
         const saveState = (): void => {
-            if (this.options.saveState) {
-                this.saveStateHandler.saveState();
+            if (this._options.saveState) {
+                this._saveStateHandler.saveState();
             }
         };
 
         if (!node) {
             // Called with empty node -> deselect current node
-            this.deselectCurrentNode();
+            this._deselectCurrentNode();
             saveState();
             return;
         }
@@ -803,13 +807,13 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         const selectOptions = { ...defaultOptions, ...(optionsParam ?? {}) };
 
         const canSelect = (): boolean => {
-            if (this.options.onCanSelectNode) {
+            if (this._options.onCanSelectNode) {
                 return (
-                    this.options.selectable &&
-                    this.options.onCanSelectNode(node)
+                    this._options.selectable &&
+                    this._options.onCanSelectNode(node)
                 );
             } else {
-                return this.options.selectable;
+                return this._options.selectable;
             }
         };
 
@@ -817,45 +821,42 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             return;
         }
 
-        if (this.selectNodeHandler.isNodeSelected(node)) {
+        if (this._selectNodeHandler.isNodeSelected(node)) {
             if (selectOptions.mustToggle) {
-                this.deselectCurrentNode();
-                this.triggerEvent("tree.select", {
+                this._deselectCurrentNode();
+                this._triggerEvent("tree.select", {
                     node: null,
                     previous_node: node,
                 });
             }
         } else {
             const deselectedNode = this.getSelectedNode() || null;
-            this.deselectCurrentNode();
+            this._deselectCurrentNode();
             this.addToSelection(node, selectOptions.mustSetFocus);
 
-            this.triggerEvent("tree.select", {
+            this._triggerEvent("tree.select", {
                 deselected_node: deselectedNode,
                 node,
             });
-            this.openParents(node);
+            this._openParents(node);
         }
 
         saveState();
     }
 
-    private getAutoOpenMaxLevel(): number {
-        if (this.options.autoOpen === true) {
+    private _getAutoOpenMaxLevel(): number {
+        if (this._options.autoOpen === true) {
             return -1;
-        } else if (typeof this.options.autoOpen === "number") {
-            return this.options.autoOpen;
-        } else if (typeof this.options.autoOpen === "string") {
-            return parseInt(this.options.autoOpen, 10);
+        } else if (typeof this._options.autoOpen === "number") {
+            return this._options.autoOpen;
+        } else if (typeof this._options.autoOpen === "string") {
+            return parseInt(this._options.autoOpen, 10);
         } else {
             return 0;
         }
     }
 
-    private getDataUrlInfo(node: Node | null): JQuery.AjaxSettings | null {
-        const dataUrl =
-            this.options.dataUrl ?? (this.element.data("url") as null | string);
-
+    private _getDataUrlInfo(node: Node | null): JQuery.AjaxSettings | null {
         const getUrlFromString = (url: string): JQuery.AjaxSettings => {
             const urlInfo: JQuery.AjaxSettings = { url };
 
@@ -871,7 +872,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
                 urlInfo.data = data;
             } else {
                 // Add selected_node parameter
-                const selectedNodeId = this.getNodeIdToBeSelected();
+                const selectedNodeId = this._getNodeIdToBeSelected();
                 if (selectedNodeId) {
                     const data = { selected_node: selectedNodeId };
                     urlInfo.data = data;
@@ -879,6 +880,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
             }
         };
 
+        const dataUrl = this._options.dataUrl;
         if (typeof dataUrl === "function") {
             return dataUrl(node);
         } else if (typeof dataUrl === "string") {
@@ -891,8 +893,8 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
     }
 
-    private getDefaultClosedIcon(): string {
-        if (this.options.rtl) {
+    private _getDefaultClosedIcon(): string {
+        if (this._options.rtl) {
             // triangle to the left
             return "&#x25c0;";
         } else {
@@ -901,7 +903,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
     }
 
-    private getNode(element: HTMLElement): Node | null {
+    private _getNode(element: HTMLElement): Node | null {
         const liElement = element.closest("li.jqtree_common");
 
         if (liElement) {
@@ -911,100 +913,95 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
     }
 
-    private getNodeElement(element: HTMLElement): NodeElement | null {
-        const node = this.getNode(element);
+    private _getNodeElement(element: HTMLElement): NodeElement | null {
+        const node = this._getNode(element);
         if (node) {
-            return this.getNodeElementForNode(node);
+            return this._getNodeElementForNode(node);
         } else {
             return null;
         }
     }
 
-    private getNodeElementForNode(node: Node): NodeElement {
+    private _getNodeElementForNode(node: Node): NodeElement {
         if (node.isFolder()) {
-            return this.createFolderElement(node);
+            return this._createFolderElement(node);
         } else {
-            return this.createNodeElement(node);
+            return this._createNodeElement(node);
         }
     }
 
-    private getNodeIdToBeSelected(): NodeId | null {
-        if (this.options.saveState) {
-            return this.saveStateHandler.getNodeIdToBeSelected();
+    private _getNodeIdToBeSelected(): NodeId | null {
+        if (this._options.saveState) {
+            return this._saveStateHandler.getNodeIdToBeSelected();
         } else {
             return null;
         }
     }
 
-    private getRtlOption(): boolean {
-        if (this.options.rtl != null) {
-            return this.options.rtl;
+    private _initData(): void {
+        if (this._options.data) {
+            this._doLoadData(this._options.data, null);
         } else {
-            const dataRtl = this.element.data("rtl") as unknown;
-
-            if (
-                dataRtl !== null &&
-                dataRtl !== false &&
-                dataRtl !== undefined
-            ) {
-                return true;
-            } else {
-                return false;
-            }
-        }
-    }
-
-    private initData(): void {
-        if (this.options.data) {
-            this.doLoadData(this.options.data, null);
-        } else {
-            const dataUrl = this.getDataUrlInfo(null);
+            const dataUrl = this._getDataUrlInfo(null);
 
             if (dataUrl) {
-                this.doLoadDataFromUrl(null, null, null);
+                this._doLoadDataFromUrl(null, null, null);
             } else {
-                this.doLoadData([], null);
+                this._doLoadData([], null);
             }
         }
     }
 
-    private initTree(data: NodeData[]): void {
+    private _initTree(data: NodeData[]): void {
         const doInit = (): void => {
-            if (!this.isInitialized) {
-                this.isInitialized = true;
-                this.triggerEvent("tree.init");
+            if (!this._isInitialized) {
+                this._isInitialized = true;
+                this._triggerEvent("tree.init");
             }
         };
 
-        this.tree = new this.options.nodeClass(
+        this._tree = new this._options.nodeClass(
             null,
             true,
-            this.options.nodeClass,
+            this._options.nodeClass,
         );
 
-        this.selectNodeHandler.clear();
+        this._selectNodeHandler.clear();
 
-        this.tree.loadFromData(data);
+        this._tree.loadFromData(data);
 
-        const mustLoadOnDemand = this.setInitialState();
+        const mustLoadOnDemand = this._setInitialState();
 
-        this.refreshElements(null);
+        this._refreshElements(null);
 
-        if (!mustLoadOnDemand) {
-            doInit();
-        } else {
+        if (mustLoadOnDemand) {
             // Load data on demand and then init the tree
-            this.setInitialStateOnDemand(doInit);
+            this._setInitialStateOnDemand(doInit);
+        } else {
+            doInit();
         }
     }
 
-    private isFocusOnTree(): boolean {
+    // Does an element in the tree have the focus?
+    private _isFocusOnTree(): boolean {
         const activeElement = document.activeElement;
 
-        return activeElement?.tagName === "SPAN" && this.containsElement(activeElement as HTMLElement);
+        /* istanbul ignore if */
+        if (!activeElement) {
+            return false;
+        }
+
+        // The keyboard must still work for input elements.
+        const tagName = activeElement.tagName;
+        if (tagName !== "A" && tagName !== "SPAN") {
+            return false;
+        }
+
+        const node = this._getNode(activeElement as HTMLElement);
+        return node?.tree === this._tree;
     }
 
-    private isSelectedNodeInSubtree(subtree: Node): boolean {
+    private _isSelectedNodeInSubtree(subtree: Node): boolean {
         const selectedNode = this.getSelectedNode();
 
         if (!selectedNode) {
@@ -1014,64 +1011,66 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
     }
 
-    private loadFolderOnDemand(
+    private _loadFolderOnDemand(
         node: Node,
         slide = true,
         onFinished?: OnFinishOpenNode,
     ): void {
         node.is_loading = true;
 
-        this.doLoadDataFromUrl(null, node, () => {
-            this.openNodeInternal(node, slide, onFinished);
+        this._doLoadDataFromUrl(null, node, () => {
+            this._openNodeInternal(node, slide, onFinished);
         });
     }
 
-    private loadSubtree(data: NodeData[], parentNode: Node): void {
+    private _loadSubtree(data: NodeData[], parentNode: Node): void {
         parentNode.loadFromData(data);
 
         parentNode.load_on_demand = false;
         parentNode.is_loading = false;
 
-        this.refreshElements(parentNode);
+        this._refreshElements(parentNode);
     }
 
-    private mouseCapture(positionInfo: PositionInfo): boolean | null {
-        if (this.options.dragAndDrop) {
-            return this.dndHandler.mouseCapture(positionInfo);
-        } else {
+    private _mouseCapture(positionInfo: PositionInfo): boolean | null {
+        if (!this._options.dragAndDrop) {
             return false;
         }
-    }
 
-    private mouseDrag(positionInfo: PositionInfo): boolean {
-        if (this.options.dragAndDrop) {
-            const result = this.dndHandler.mouseDrag(positionInfo);
+        return this._dndHandler.mouseCapture(positionInfo);
+    }
 
-            this.scrollHandler.checkScrolling(positionInfo);
-            return result;
-        } else {
+    private _mouseDrag(positionInfo: PositionInfo): boolean {
+        /* istanbul ignore if */
+        if (!this._options.dragAndDrop) {
             return false;
         }
+
+        const result = this._dndHandler.mouseDrag(positionInfo);
+        this._scrollHandler.checkScrolling(positionInfo);
+        return result;
     }
 
-    private mouseStart(positionInfo: PositionInfo): boolean {
-        if (this.options.dragAndDrop) {
-            return this.dndHandler.mouseStart(positionInfo);
-        } else {
+    private _mouseStart(positionInfo: PositionInfo): boolean {
+        /* istanbul ignore if */
+        if (!this._options.dragAndDrop) {
             return false;
         }
+
+        return this._dndHandler.mouseStart(positionInfo);
     }
 
-    private mouseStop(positionInfo: PositionInfo): boolean {
-        if (this.options.dragAndDrop) {
-            this.scrollHandler.stopScrolling();
-            return this.dndHandler.mouseStop(positionInfo);
-        } else {
+    private _mouseStop(positionInfo: PositionInfo): boolean {
+        /* istanbul ignore if */
+        if (!this._options.dragAndDrop) {
             return false;
         }
+
+        this._scrollHandler.stopScrolling();
+        return this._dndHandler.mouseStop(positionInfo);
     }
 
-    private openNodeInternal(
+    private _openNodeInternal(
         node: Node,
         slide = true,
         onFinished?: OnFinishOpenNode,
@@ -1085,17 +1084,17 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
                 return;
             }
 
-            const folderElement = this.createFolderElement(_node);
+            const folderElement = this._createFolderElement(_node);
             folderElement.open(
                 _onFinished,
                 _slide,
-                this.options.animationSpeed,
+                this._options.animationSpeed,
             );
         };
 
         if (node.isFolder() || node.isEmptyFolder) {
             if (node.load_on_demand) {
-                this.loadFolderOnDemand(node, slide, onFinished);
+                this._loadFolderOnDemand(node, slide, onFinished);
             } else {
                 let parent = node.parent;
 
@@ -1108,12 +1107,12 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
                 }
 
                 doOpenNode(node, slide, onFinished);
-                this.saveState();
+                this._saveState();
             }
         }
     }
 
-    private openParents(node: Node) {
+    private _openParents(node: Node) {
         const parent = node.parent;
 
         if (parent?.parent && !parent.is_open) {
@@ -1125,50 +1124,50 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
     Redraw the tree or part of the tree.
      from_node: redraw this subtree
     */
-    private refreshElements(fromNode: Node | null): void {
-        const mustSetFocus = this.isFocusOnTree();
+    private _refreshElements(fromNode: Node | null): void {
+        const mustSetFocus = this._isFocusOnTree();
         const mustSelect = fromNode
-            ? this.isSelectedNodeInSubtree(fromNode)
+            ? this._isSelectedNodeInSubtree(fromNode)
             : false;
 
-        this.renderer.render(fromNode);
+        this._renderer.render(fromNode);
 
         if (mustSelect) {
-            this.selectCurrentNode(mustSetFocus);
+            this._selectCurrentNode(mustSetFocus);
         }
 
-        this.triggerEvent("tree.refresh");
+        this._triggerEvent("tree.refresh");
     }
 
-    private saveState(): void {
-        if (this.options.saveState) {
-            this.saveStateHandler.saveState();
+    private _saveState(): void {
+        if (this._options.saveState) {
+            this._saveStateHandler.saveState();
         }
     }
 
-    private selectCurrentNode(mustSetFocus: boolean): void {
+    private _selectCurrentNode(mustSetFocus: boolean): void {
         const node = this.getSelectedNode();
         if (node) {
-            const nodeElement = this.getNodeElementForNode(node);
+            const nodeElement = this._getNodeElementForNode(node);
             nodeElement.select(mustSetFocus);
         }
     }
 
     // Set initial state, either by restoring the state or auto-opening nodes
     // result: must load nodes on demand?
-    private setInitialState(): boolean {
+    private _setInitialState(): boolean {
         const restoreState = (): [boolean, boolean] => {
             // result: is state restored, must load on demand?
-            if (!this.options.saveState) {
+            if (!this._options.saveState) {
                 return [false, false];
             } else {
-                const state = this.saveStateHandler.getStateFromStorage();
+                const state = this._saveStateHandler.getStateFromStorage();
 
                 if (!state) {
                     return [false, false];
                 } else {
                     const mustLoadOnDemand =
-                        this.saveStateHandler.setInitialState(state);
+                        this._saveStateHandler.setInitialState(state);
 
                     // return true: the state is restored
                     return [true, mustLoadOnDemand];
@@ -1178,14 +1177,14 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
 
         const autoOpenNodes = (): boolean => {
             // result: must load on demand?
-            if (this.options.autoOpen === false) {
+            if (this._options.autoOpen === false) {
                 return false;
             }
 
-            const maxLevel = this.getAutoOpenMaxLevel();
+            const maxLevel = this._getAutoOpenMaxLevel();
             let mustLoadOnDemand = false;
 
-            this.tree.iterate((node: Node, level: number) => {
+            this._tree.iterate((node: Node, level: number) => {
                 if (node.load_on_demand) {
                     mustLoadOnDemand = true;
                     return false;
@@ -1211,40 +1210,36 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
 
     // Set the initial state for nodes that are loaded on demand
     // Call cb_finished when done
-    private setInitialStateOnDemand(cbFinished: () => void): void {
+    private _setInitialStateOnDemand(cbFinished: () => void): void {
         const restoreState = (): boolean => {
-            if (!this.options.saveState) {
+            const state = this._saveStateHandler.getStateFromStorage();
+
+            if (!state) {
                 return false;
             } else {
-                const state = this.saveStateHandler.getStateFromStorage();
-
-                if (!state) {
-                    return false;
-                } else {
-                    this.saveStateHandler.setInitialStateOnDemand(
-                        state,
-                        cbFinished,
-                    );
+                this._saveStateHandler.setInitialStateOnDemand(
+                    state,
+                    cbFinished,
+                );
 
-                    return true;
-                }
+                return true;
             }
         };
 
         const autoOpenNodes = (): void => {
-            const maxLevel = this.getAutoOpenMaxLevel();
+            const maxLevel = this._getAutoOpenMaxLevel();
             let loadingCount = 0;
 
             const loadAndOpenNode = (node: Node): void => {
                 loadingCount += 1;
-                this.openNodeInternal(node, false, () => {
+                this._openNodeInternal(node, false, () => {
                     loadingCount -= 1;
                     openNodes();
                 });
             };
 
             const openNodes = (): void => {
-                this.tree.iterate((node: Node, level: number) => {
+                this._tree.iterate((node: Node, level: number) => {
                     if (node.load_on_demand) {
                         if (!node.is_loading) {
                             loadAndOpenNode(node);
@@ -1252,7 +1247,7 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
 
                         return false;
                     } else {
-                        this.openNodeInternal(node, false);
+                        this._openNodeInternal(node, false);
 
                         return level !== maxLevel;
                     }
@@ -1271,14 +1266,107 @@ export class JqTreeWidget extends SimpleWidget<JQTreeOptions> {
         }
     }
 
-    private triggerEvent(
+    private _triggerEvent(
         eventName: string,
         values?: Record<string, unknown>,
-    ): JQuery.Event {
+    ): boolean {
         const event = jQuery.Event(eventName, values);
-        this.element.trigger(event);
-        return event;
+        this._element.trigger(event);
+        return !event.isDefaultPrevented();
     }
 }
 
-SimpleWidget.register(JqTreeWidget, "tree");
+const register = (): void => {
+    const getWidgetData = (
+        el: HTMLElement,
+        dataKey: string,
+    ): JqTreeWidget | null => {
+        const widget = jQuery.data(el, dataKey) as unknown;
+
+        if (widget && widget instanceof JqTreeWidget) {
+            return widget;
+        } else {
+            return null;
+        }
+    };
+
+    const createWidget = ($el: JQuery, options: null | Partial<JQTreeOptions>): JQuery => {
+        for (const el of $el.get()) {
+            const existingWidget = getWidgetData(el, "jqtree");
+
+            if (!existingWidget) {
+                const widget = new JqTreeWidget(el, options ?? {});
+
+                if (!jQuery.data(el, "jqtree")) {
+                    jQuery.data(el, "jqtree", widget);
+                }
+
+                // Call init after setting data, so we can call methods
+                widget.init();
+            }
+        }
+
+        return $el;
+    };
+
+    const destroyWidget = ($el: JQuery): void => {
+        for (const el of $el.get()) {
+            const widget = getWidgetData(el, "jqtree");
+
+            if (widget) {
+                widget.destroy();
+            }
+
+            jQuery.removeData(el, "jqtree");
+        }
+    };
+
+    const callFunction = (
+        $el: JQuery,
+        functionName: string,
+        args: unknown[],
+    ): unknown => {
+        let result = null;
+
+        for (const el of $el.get()) {
+            const widget = jQuery.data(el, "jqtree") as unknown;
+
+            if (widget && widget instanceof JqTreeWidget) {
+                const widgetFunction = widget[functionName];
+
+                if (widgetFunction && typeof widgetFunction === "function") {
+                    result = widgetFunction.apply(widget, args) as unknown;
+                }
+            }
+        }
+
+        return result;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    (jQuery.fn as any).tree = function (
+        this: JQuery,
+        argument1: unknown,
+        ...args: unknown[]
+    ) {
+        if (!argument1) {
+            return createWidget(this, null);
+        } else if (typeof argument1 === "object") {
+            const options = argument1 as unknown;
+            return createWidget(this, options as JQTreeOptions);
+        } else if (typeof argument1 === "string" && argument1[0] !== "_") {
+            const functionName = argument1;
+
+            if (argument1 === "destroy") {
+                destroyWidget(this);
+                return undefined;
+            } else {
+                return callFunction(this, functionName, args);
+            }
+        } else {
+            return undefined;
+        }
+    };
+};
+
+register();