jqtree 1.9.0 → 2.0.0

package/src/scrollHandler/createScrollParent.ts

@@ -1,51 +0,0 @@
-import type { ScrollParent } from "./scrollParent";
-
-import ContainerScrollParent from "./containerScrollParent";
-import DocumentScrollParent from "./documentScrollParent";
-
-const isOverflow = (overflowValue: string) =>
-    overflowValue === "auto" || overflowValue === "scroll";
-
-const hasOverFlow = (element: HTMLElement): boolean => {
-    const style = getComputedStyle(element);
-
-    return isOverflow(style.overflowX) || isOverflow(style.overflowY);
-};
-
-const getParentWithOverflow = (
-    treeElement: HTMLElement,
-): HTMLElement | null => {
-    if (hasOverFlow(treeElement)) {
-        return treeElement;
-    }
-
-    let parent = treeElement.parentElement;
-
-    while (parent) {
-        if (hasOverFlow(parent)) {
-            return parent;
-        }
-
-        parent = parent.parentElement;
-    }
-
-    return null;
-};
-
-const createScrollParent = (
-    treeElement: HTMLElement,
-    refreshHitAreas: () => void,
-): ScrollParent => {
-    const container = getParentWithOverflow(treeElement);
-
-    if (container && container.tagName !== "HTML") {
-        return new ContainerScrollParent({
-            container,
-            refreshHitAreas,
-        });
-    } else {
-        return new DocumentScrollParent({ refreshHitAreas, treeElement });
-    }
-};
-
-export default createScrollParent;

package/src/scrollHandler/documentScrollParent.ts

@@ -1,104 +0,0 @@
-import type {
-    HorizontalScrollDirection,
-    VerticalScrollDirection,
-} from "./scrollParent";
-
-import { getOffsetTop } from "../positionUtils";
-import { ScrollParent } from "./scrollParent";
-
-interface Params {
-    refreshHitAreas: () => void;
-    treeElement: HTMLElement;
-}
-
-export default class DocumentScrollParent extends ScrollParent {
-    private _documentScrollHeight?: number;
-    private _documentScrollWidth?: number;
-    private _treeElement: HTMLElement;
-
-    constructor({ refreshHitAreas, treeElement }: Params) {
-        super({ container: document.documentElement, refreshHitAreas });
-
-        this._treeElement = treeElement;
-    }
-
-    public scrollToY(top: number): void {
-        const treeTop = getOffsetTop(this._treeElement);
-
-        super.scrollToY(top + treeTop);
-    }
-
-    public stopScrolling() {
-        super.stopScrolling();
-
-        this._documentScrollHeight = undefined;
-        this._documentScrollWidth = undefined;
-    }
-
-    protected getNewHorizontalScrollDirection(
-        pageX: number,
-    ): HorizontalScrollDirection | undefined {
-        const scrollLeft = this.container.scrollLeft;
-        const windowWidth = window.innerWidth;
-
-        const isNearRightEdge = pageX > windowWidth - 20;
-        const isNearLeftEdge = pageX - scrollLeft < 20;
-
-        if (isNearRightEdge && this._canScrollRight()) {
-            return "right";
-        }
-
-        if (isNearLeftEdge) {
-            return "left";
-        }
-
-        return undefined;
-    }
-
-    protected getNewVerticalScrollDirection(
-        pageY: number,
-    ): undefined | VerticalScrollDirection {
-        const scrollTop = this.container.scrollTop;
-        const distanceTop = pageY - scrollTop;
-
-        if (distanceTop < 20) {
-            return "top";
-        }
-
-        const windowHeight = window.innerHeight;
-
-        if (windowHeight - (pageY - scrollTop) < 20 && this._canScrollDown()) {
-            return "bottom";
-        }
-
-        return undefined;
-    }
-
-    private _canScrollDown() {
-        return (
-            this.container.scrollTop + this.container.clientHeight <
-            this._getDocumentScrollHeight()
-        );
-    }
-
-    private _canScrollRight() {
-        return (
-            this.container.scrollLeft + this.container.clientWidth <
-            this._getDocumentScrollWidth()
-        );
-    }
-
-    private _getDocumentScrollHeight() {
-        // Store the original scroll height because the scroll height can increase when the drag element is moved beyond the scroll height.
-        this._documentScrollHeight ??= this.container.scrollHeight;
-
-        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.
-        this._documentScrollWidth ??= this.container.scrollWidth;
-
-        return this._documentScrollWidth;
-    }
-}

package/src/scrollHandler/scrollParent.ts

@@ -1,117 +0,0 @@
-export type HorizontalScrollDirection = "left" | "right";
-export type VerticalScrollDirection = "bottom" | "top";
-
-interface ConstructorParams {
-    container: HTMLElement;
-    refreshHitAreas: () => void;
-}
-
-export abstract class ScrollParent {
-    protected container: HTMLElement;
-    protected horizontalScrollDirection?: HorizontalScrollDirection;
-    protected horizontalScrollTimeout?: number;
-
-    protected refreshHitAreas: () => void;
-    protected verticalScrollDirection?: VerticalScrollDirection;
-    protected verticalScrollTimeout?: number;
-
-    constructor({ container, refreshHitAreas }: ConstructorParams) {
-        this.container = container;
-        this.refreshHitAreas = refreshHitAreas;
-    }
-
-    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 this.container.scrollLeft;
-    }
-
-    public scrollToY(top: number): void {
-        this.container.scrollTop = top;
-    }
-
-    public stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
-    }
-
-    protected abstract getNewHorizontalScrollDirection(
-        pageX: number,
-    ): HorizontalScrollDirection | undefined;
-    protected abstract getNewVerticalScrollDirection(
-        pageY: number,
-    ): undefined | VerticalScrollDirection;
-
-    protected scrollHorizontally() {
-        if (!this.horizontalScrollDirection) {
-            return;
-        }
-
-        const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
-        this.container.scrollBy({
-            behavior: "instant",
-            left: distance,
-            top: 0,
-        });
-
-        this.refreshHitAreas();
-
-        setTimeout(this.scrollHorizontally.bind(this), 40);
-    }
-
-    protected scrollVertically() {
-        if (!this.verticalScrollDirection) {
-            return;
-        }
-
-        const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-        this.container.scrollBy({
-            behavior: "instant",
-            left: 0,
-            top: distance,
-        });
-
-        this.refreshHitAreas();
-
-        setTimeout(this.scrollVertically.bind(this), 40);
-    }
-}

package/src/scrollHandler.ts

@@ -1,55 +0,0 @@
-import type { PositionInfo } from "./mouseUtils";
-import type { ScrollParent } from "./scrollHandler/scrollParent";
-
-import createScrollParent from "./scrollHandler/createScrollParent";
-
-interface ScrollHandlerParams {
-    refreshHitAreas: () => void;
-    treeElement: HTMLElement;
-}
-
-export default class ScrollHandler {
-    private _refreshHitAreas: () => void;
-    private _scrollParent?: ScrollParent;
-    private _treeElement: HTMLElement;
-
-    constructor({ refreshHitAreas, treeElement }: ScrollHandlerParams) {
-        this._refreshHitAreas = refreshHitAreas;
-        this._scrollParent = undefined;
-        this._treeElement = treeElement;
-    }
-
-    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();
-    }
-
-    private _checkHorizontalScrolling(positionInfo: PositionInfo): void {
-        this._getScrollParent().checkHorizontalScrolling(positionInfo.pageX);
-    }
-
-    private _checkVerticalScrolling(positionInfo: PositionInfo): void {
-        this._getScrollParent().checkVerticalScrolling(positionInfo.pageY);
-    }
-
-    private _getScrollParent(): ScrollParent {
-        this._scrollParent ??= createScrollParent(
-            this._treeElement,
-            this._refreshHitAreas,
-        );
-
-        return this._scrollParent;
-    }
-}

package/src/selectNodeHandler.ts

@@ -1,111 +0,0 @@
-import type { GetNodeById } from "./jqtreeMethodTypes";
-import type { Node } from "./node";
-
-interface SelectNodeHandlerParameters {
-    getNodeById: GetNodeById;
-}
-
-export default class SelectNodeHandler {
-    private _getNodeById: GetNodeById;
-    private _selectedNodes: Set<NodeId>;
-    private _selectedSingleNode: Node | null;
-
-    constructor({ getNodeById }: SelectNodeHandlerParameters) {
-        this._getNodeById = getNodeById;
-        this._selectedNodes = new Set<NodeId>();
-        this.clear();
-    }
-
-    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;
-        } else {
-            return false;
-        }
-    }
-
-    public getSelectedNodes(): Node[] {
-        if (this._selectedSingleNode) {
-            return [this._selectedSingleNode];
-        } else {
-            const selectedNodes: Node[] = [];
-
-            this._selectedNodes.forEach((id) => {
-                const node = this._getNodeById(id);
-                if (node) {
-                    selectedNodes.push(node);
-                }
-            });
-
-            return selectedNodes;
-        }
-    }
-
-    public getSelectedNodesUnder(parent: Node): Node[] {
-        if (this._selectedSingleNode) {
-            if (parent.isParentOf(this._selectedSingleNode)) {
-                return [this._selectedSingleNode];
-            } else {
-                return [];
-            }
-        } else {
-            const selectedNodes: Node[] = [];
-
-            this._selectedNodes.forEach((id) => {
-                const node = this._getNodeById(id);
-                if (node && parent.isParentOf(node)) {
-                    selectedNodes.push(node);
-                }
-            });
-
-            return selectedNodes;
-        }
-    }
-
-    public isNodeSelected(node: Node): boolean {
-        if (node.id != null) {
-            return this._selectedNodes.has(node.id);
-        } else if (this._selectedSingleNode) {
-            return this._selectedSingleNode.element === node.element;
-        } else {
-            return false;
-        }
-    }
-
-    public removeFromSelection(node: Node, includeChildren = false): void {
-        if (node.id == null) {
-            if (
-                this._selectedSingleNode &&
-                node.element === this._selectedSingleNode.element
-            ) {
-                this._selectedSingleNode = null;
-            }
-        } else {
-            this._selectedNodes.delete(node.id);
-
-            if (includeChildren) {
-                node.iterate(() => {
-                    if (node.id != null) {
-                        this._selectedNodes.delete(node.id);
-                    }
-                    return true;
-                });
-            }
-        }
-    }
-}

package/src/simple.widget.ts

@@ -1,134 +0,0 @@
-const register = (widgetClass: unknown, widgetName: string): void => {
-    const getDataKey = (): string => `simple_widget_${widgetName}`;
-
-    const getWidgetData = (
-        el: HTMLElement,
-        dataKey: string,
-    ): null | SimpleWidget<unknown> => {
-        const widget = jQuery.data(el, dataKey) as unknown;
-
-        if (widget && widget instanceof SimpleWidget) {
-            return widget;
-        } else {
-            return null;
-        }
-    };
-
-    const createWidget = ($el: JQuery, options: unknown): JQuery => {
-        const dataKey = getDataKey();
-
-        for (const el of $el.get()) {
-            const existingWidget = getWidgetData(el, dataKey);
-
-            if (!existingWidget) {
-                const simpleWidgetClass = widgetClass as typeof SimpleWidget;
-                const widget = new simpleWidgetClass(el, options);
-
-                if (!jQuery.data(el, dataKey)) {
-                    jQuery.data(el, dataKey, widget);
-                }
-
-                // Call init after setting data, so we can call methods
-                widget.init();
-            }
-        }
-
-        return $el;
-    };
-
-    const destroyWidget = ($el: JQuery): void => {
-        const dataKey = getDataKey();
-
-        for (const el of $el.get()) {
-            const widget = getWidgetData(el, dataKey);
-
-            if (widget) {
-                widget.destroy();
-            }
-
-            jQuery.removeData(el, dataKey);
-        }
-    };
-
-    const callFunction = (
-        $el: JQuery,
-        functionName: string,
-        args: unknown[],
-    ): unknown => {
-        let result = null;
-
-        for (const el of $el.get()) {
-            const widget = jQuery.data(el, getDataKey()) as unknown;
-
-            if (widget && widget instanceof SimpleWidget) {
-                const simpleWidget = widget as SimpleWidget<unknown>;
-                const widgetFunction = simpleWidget[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)[widgetName] = 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);
-        } 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;
-        }
-    };
-};
-
-export default class SimpleWidget<WidgetOptions> {
-    [key: string]: unknown;
-
-    protected static defaults: unknown = {};
-
-    public $el: JQuery;
-
-    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;
-        this.options = { ...defaults, ...options };
-    }
-
-    public static register(widgetClass: unknown, widgetName: string): void {
-        register(widgetClass, widgetName);
-    }
-
-    public deinit(): void {
-        //
-    }
-
-    public destroy(): void {
-        this.deinit();
-    }
-
-    public init(): void {
-        //
-    }
-}

package/src/util.ts

@@ -1,5 +0,0 @@
-export const isInt = (n: unknown): boolean =>
-    typeof n === "number" && n % 1 === 0;
-
-export const getBoolString = (value: unknown): string =>
-    value ? "true" : "false";