jqtree 1.9.1 → 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/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";