jqtree 1.9.1 → 2.0.0

package/src/animation.ts

@@ -1,48 +0,0 @@
-export type AnimationSpeed = "fast" | "slow" | number;
-
-export const getAnimationDuration = (duration: AnimationSpeed): number => {
-  if (typeof duration === "number") {
-    return duration;
-  }
-
-  return duration === "slow" ? 600 : 200;
-};
-
-export const slideDown = (
-  element: HTMLElement,
-  animationSpeed: AnimationSpeed,
-  onFinished: () => void,
-): void => {
-  element.style.display = "block";
-
-  const animation = element.animate(
-    [
-      { height: "0", overflow: "hidden" },
-      { height: `${element.scrollHeight}px`, overflow: "hidden" },
-    ],
-    { duration: getAnimationDuration(animationSpeed) },
-  );
-
-  animation.onfinish = () => {
-    onFinished();
-  };
-};
-
-export const slideUp = (
-  element: HTMLElement,
-  animationSpeed: AnimationSpeed,
-  onFinished: () => void,
-): void => {
-  const animation = element.animate(
-    [
-      { height: `${element.scrollHeight}px`, overflow: "hidden" },
-      { height: "0", overflow: "hidden" },
-    ],
-    { duration: getAnimationDuration(animationSpeed) },
-  );
-
-  animation.onfinish = () => {
-    element.style.display = "none";
-    onFinished();
-  };
-};

package/src/dataLoader.ts

@@ -1,143 +0,0 @@
-import type { LoadData, TriggerEvent } from "./jqtreeMethodTypes";
-import type { DataFilter, OnLoadFailed, OnLoading } from "./jqtreeOptions";
-import type { Node } from "./node";
-
-export type HandleFinishedLoading = () => void;
-
-interface DataLoaderParams {
-    dataFilter?: DataFilter;
-    loadData: LoadData;
-    onLoadFailed?: OnLoadFailed;
-    onLoading?: OnLoading;
-    treeElement: HTMLElement;
-    triggerEvent: TriggerEvent;
-}
-
-export default class DataLoader {
-    private _dataFilter?: DataFilter;
-    private _loadData: LoadData;
-    private _onLoadFailed?: OnLoadFailed;
-    private _onLoading?: OnLoading;
-    private _treeElement: HTMLElement;
-    private _triggerEvent: TriggerEvent;
-
-    constructor({
-        dataFilter,
-        loadData,
-        onLoadFailed,
-        onLoading,
-        treeElement,
-        triggerEvent,
-    }: DataLoaderParams) {
-        this._dataFilter = dataFilter;
-        this._loadData = loadData;
-        this._onLoadFailed = onLoadFailed;
-        this._onLoading = onLoading;
-        this._treeElement = treeElement;
-        this._triggerEvent = triggerEvent;
-    }
-
-    public loadFromUrl(
-        urlInfo: JQuery.AjaxSettings | null | string,
-        parentNode: Node | null,
-        onFinished: HandleFinishedLoading | null,
-    ): void {
-        if (!urlInfo) {
-            return;
-        }
-
-        const element = this._getDomElement(parentNode);
-        this._addLoadingClass(element);
-        this._notifyLoading(true, parentNode, element);
-
-        const stopLoading = (): void => {
-            this._removeLoadingClass(element);
-            this._notifyLoading(false, parentNode, element);
-        };
-
-        const handleSuccess = (data: NodeData[]): void => {
-            stopLoading();
-            this._loadData(this._parseData(data), parentNode);
-
-            if (onFinished && typeof onFinished === "function") {
-                onFinished();
-            }
-        };
-
-        const handleError = (jqXHR: JQuery.jqXHR): void => {
-            stopLoading();
-
-            if (this._onLoadFailed) {
-                this._onLoadFailed(jqXHR);
-            }
-        };
-
-        this._submitRequest(urlInfo, handleSuccess, handleError);
-    }
-
-    private _addLoadingClass(element: HTMLElement): void {
-        element.classList.add("jqtree-loading");
-    }
-
-    private _getDomElement(parentNode: Node | null): HTMLElement {
-        if (parentNode?.element) {
-            return parentNode.element;
-        } else {
-            return this._treeElement;
-        }
-    }
-
-    private _notifyLoading(
-        isLoading: boolean,
-        node: Node | null,
-        element: HTMLElement,
-    ): void {
-        const $el = jQuery(element);
-
-        if (this._onLoading) {
-            this._onLoading(isLoading, node, $el);
-        }
-
-        this._triggerEvent("tree.loading_data", {
-            $el,
-            isLoading,
-            node,
-        });
-    }
-
-    private _parseData(data: NodeData[]): NodeData[] {
-        if (this._dataFilter) {
-            return this._dataFilter(data);
-        } else {
-            return data;
-        }
-    }
-
-    private _removeLoadingClass(element: HTMLElement): void {
-        element.classList.remove("jqtree-loading");
-    }
-
-    private _submitRequest(
-        urlInfoInput: JQuery.AjaxSettings | string,
-        handleSuccess: JQuery.Ajax.SuccessCallback<any>,
-        handleError: JQuery.Ajax.ErrorCallback<any>,
-    ): void {
-        const urlInfo =
-            typeof urlInfoInput === "string"
-                ? { url: urlInfoInput }
-                : urlInfoInput;
-
-        const ajaxSettings: JQuery.AjaxSettings = {
-            cache: false,
-            dataType: "json",
-            error: handleError,
-            method: "GET",
-            success: handleSuccess,
-            ...urlInfo,
-        };
-
-        ajaxSettings.method = ajaxSettings.method?.toUpperCase() ?? "GET";
-
-        void jQuery.ajax(ajaxSettings);
-    }
-}

package/src/dragAndDropHandler/binarySearch.ts

@@ -1,27 +0,0 @@
-function binarySearch<T>(items: T[], compareFn: (a: T) => number): null | T {
-    let low = 0;
-    let high = items.length;
-
-    while (low < high) {
-        const mid = (low + high) >> 1;
-        const item = items[mid];
-
-        if (item === undefined) {
-            return null;
-        }
-
-        const compareResult = compareFn(item);
-
-        if (compareResult > 0) {
-            high = mid;
-        } else if (compareResult < 0) {
-            low = mid + 1;
-        } else {
-            return item;
-        }
-    }
-
-    return null;
-}
-
-export default binarySearch;

package/src/dragAndDropHandler/dragElement.ts

@@ -1,54 +0,0 @@
-interface DragElementParams {
-    autoEscape: boolean;
-    nodeName: string;
-    offsetX: number;
-    offsetY: number;
-    treeElement: HTMLElement;
-}
-
-class DragElement {
-    private _element: HTMLElement;
-    private _offsetX: number;
-    private _offsetY: number;
-
-    constructor({
-        autoEscape,
-        nodeName,
-        offsetX,
-        offsetY,
-        treeElement,
-    }: DragElementParams) {
-        this._offsetX = offsetX;
-        this._offsetY = offsetY;
-
-        this._element = this._createElement(nodeName, autoEscape);
-
-        treeElement.appendChild(this._element);
-    }
-
-    public move(pageX: number, pageY: number): void {
-        this._element.style.left = `${pageX - this._offsetX}px`;
-        this._element.style.top = `${pageY - this._offsetY}px`;
-    }
-
-    public remove(): void {
-        this._element.remove();
-    }
-
-    private _createElement(nodeName: string, autoEscape: boolean) {
-        const element = document.createElement("span");
-        element.classList.add("jqtree-title", "jqtree-dragging");
-
-        if (autoEscape) {
-            element.textContent = nodeName;
-        } else {
-            element.innerHTML = nodeName;
-        }
-
-        element.style.position = "absolute";
-
-        return element;
-    }
-}
-
-export default DragElement;

package/src/dragAndDropHandler/generateHitAreas.ts

@@ -1,195 +0,0 @@
-import type { Node, Position } from "../node";
-import type { HitArea } from "./types";
-
-import { getOffsetTop } from "../positionUtils";
-import iterateVisibleNodes from "./iterateVisibleNodes";
-
-interface HitPosition {
-    node: Node;
-    position: null | Position;
-    top: number;
-}
-
-export const generateHitPositions = (
-    tree: Node,
-    currentNode: Node,
-): HitPosition[] => {
-    const hitPositions: HitPosition[] = [];
-    let lastTop = 0;
-
-    const addHitPosition = (
-        node: Node,
-        position: null | Position,
-        top: number,
-    ) => {
-        hitPositions.push({
-            node,
-            position,
-            top,
-        });
-        lastTop = top;
-    };
-
-    const handleAfterOpenFolder = (node: Node, nextNode: Node | null) => {
-        if (node === currentNode || nextNode === currentNode) {
-            // Cannot move before or after current item
-            addHitPosition(node, null, lastTop);
-        } else {
-            addHitPosition(node, "after", lastTop);
-        }
-    };
-
-    const handleClosedFolder = (
-        node: Node,
-        nextNode: Node | null,
-        element: HTMLElement,
-    ) => {
-        const top = getOffsetTop(element);
-
-        if (node === currentNode) {
-            // Cannot move after current item
-            addHitPosition(node, null, top);
-        } else {
-            addHitPosition(node, "inside", top);
-
-            // Cannot move before current item
-            if (nextNode !== currentNode) {
-                addHitPosition(node, "after", top);
-            }
-        }
-    };
-
-    const handleFirstNode = (node: Node) => {
-        if (node !== currentNode && node.element) {
-            addHitPosition(node, "before", getOffsetTop(node.element));
-        }
-    };
-
-    const handleNode = (
-        node: Node,
-        nextNode: Node | null,
-        element: HTMLElement,
-    ) => {
-        const top = getOffsetTop(element);
-
-        if (node === currentNode) {
-            // Cannot move inside current item
-            addHitPosition(node, null, top);
-        } else {
-            addHitPosition(node, "inside", top);
-        }
-
-        if (nextNode === currentNode || node === currentNode) {
-            // Cannot move before or after current item
-            addHitPosition(node, null, top);
-        } else {
-            addHitPosition(node, "after", top);
-        }
-    };
-
-    const handleOpenFolder = (node: Node, element: HTMLElement) => {
-        if (node === currentNode) {
-            // Cannot move inside current item
-
-            // Dnd over the current element is not possible: add a position with type None for the top and the bottom.
-            const top = getOffsetTop(element);
-            const height = element.clientHeight;
-            addHitPosition(node, null, top);
-
-            if (height > 5) {
-                // Subtract 5 pixels to allow more space for the next element.
-                addHitPosition(node, null, top + height - 5);
-            }
-
-            // Stop iterating
-            return false;
-        }
-
-        // Cannot move before current item
-        if (node.children[0] !== currentNode) {
-            addHitPosition(node, "inside", getOffsetTop(element));
-        }
-
-        // Continue iterating
-        return true;
-    };
-
-    iterateVisibleNodes(tree, {
-        handleAfterOpenFolder,
-        handleClosedFolder,
-        handleFirstNode,
-        handleNode,
-        handleOpenFolder,
-    });
-
-    return hitPositions;
-};
-
-export const generateHitAreasForGroup = (
-    hitAreas: HitArea[],
-    positionsInGroup: HitPosition[],
-    top: number,
-    bottom: number,
-) => {
-    // limit positions in group
-    const positionCount = Math.min(positionsInGroup.length, 4);
-
-    const areaHeight = Math.round((bottom - top) / positionCount);
-    let areaTop = top;
-
-    for (let i = 0; i < positionCount; i++) {
-        const position = positionsInGroup[i] as HitPosition;
-
-        if (position.position) {
-            hitAreas.push({
-                bottom: areaTop + areaHeight,
-                node: position.node,
-                position: position.position,
-                top: areaTop,
-            });
-        }
-
-        areaTop += areaHeight;
-    }
-};
-
-export const generateHitAreasFromPositions = (
-    hitPositions: HitPosition[],
-    treeBottom: number,
-): HitArea[] => {
-    if (!hitPositions.length) {
-        return [];
-    }
-
-    let previousTop = (hitPositions[0] as HitPosition).top;
-    let group: HitPosition[] = [];
-    const hitAreas: HitArea[] = [];
-
-    for (const position of hitPositions) {
-        if (position.top !== previousTop && group.length) {
-            generateHitAreasForGroup(
-                hitAreas,
-                group,
-                previousTop,
-                position.top,
-            );
-
-            previousTop = position.top;
-            group = [];
-        }
-
-        group.push(position);
-    }
-
-    generateHitAreasForGroup(hitAreas, group, previousTop, treeBottom);
-
-    return hitAreas;
-};
-
-const generateHitAreas = (tree: Node, currentNode: Node, treeBottom: number) =>
-    generateHitAreasFromPositions(
-        generateHitPositions(tree, currentNode),
-        treeBottom,
-    );
-
-export default generateHitAreas;