@keenmate/svelte-treeview 0.2.1 → 0.3.2

package/dist/helpers/property-helper.js

@@ -0,0 +1,82 @@
+export class PropertyHelper {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    getVal(node, key) {
+        return node?.[key];
+    }
+    setVal(node, key, value) {
+        node[key] = value;
+    }
+    path(node) {
+        // root node
+        if (node === null) {
+            return null;
+        }
+        return this.getVal(node, this.props.nodePath);
+    }
+    setPath(node, path) {
+        this.setVal(node, this.props.nodePath, path);
+    }
+    hasChildren(node) {
+        return this.getVal(node, this.props.hasChildren) ?? false;
+    }
+    setHasChildren(node, hasChildren) {
+        this.setVal(node, this.props.hasChildren, hasChildren);
+    }
+    expanded(node) {
+        return this.getVal(node, this.props.expanded) ?? null;
+    }
+    setExpanded(node, expanded) {
+        this.setVal(node, this.props.expanded, expanded);
+    }
+    selected(node) {
+        return this.getVal(node, this.props.selected);
+    }
+    setSelected(node, selected) {
+        this.setVal(node, this.props.selected, selected);
+    }
+    useCallback(node) {
+        return this.getVal(node, this.props.useCallback) ?? false;
+    }
+    setUseCallback(node, useCallback) {
+        this.setVal(node, this.props.useCallback, useCallback);
+    }
+    priority(node) {
+        return this.getVal(node, this.props.priority) ?? 0;
+    }
+    setPriority(node, priority) {
+        this.setVal(node, this.props.priority, priority);
+    }
+    isDraggable(node) {
+        return this.getVal(node, this.props.isDraggable) ?? false;
+    }
+    setIsDraggable(node, isDraggable) {
+        this.setVal(node, this.props.isDraggable, isDraggable);
+    }
+    insertDisabled(node) {
+        return this.getVal(node, this.props.insertDisabled) ?? false;
+    }
+    setInsertDisabled(node, insertDisabled) {
+        this.setVal(node, this.props.insertDisabled, insertDisabled);
+    }
+    nestDisabled(node) {
+        return this.getVal(node, this.props.nestDisabled) ?? false;
+    }
+    setNestDisabled(node, nestDisabled) {
+        this.setVal(node, this.props.nestDisabled, nestDisabled);
+    }
+    checkbox(node) {
+        return this.getVal(node, this.props.checkbox) ?? null;
+    }
+    setCheckbox(node, checkbox) {
+        this.setVal(node, this.props.checkbox, checkbox);
+    }
+    visualState(node) {
+        return this.getVal(node, this.props.visualState) ?? null;
+    }
+    setVisualState(node, visualState) {
+        this.setVal(node, this.props.visualState, visualState);
+    }
+}

package/dist/helpers/selection-helpers.d.ts

@@ -1,22 +1,30 @@
-export class SelectionHelper {
-    constructor(treeHelper: any);
-    helper: any;
-    props: any;
-    path(node: any): any;
-    selected(node: any): any;
-    getChildrenWithCheckboxes(tree: any, parentNodePath: any): any;
-    changeSelection(tree: any, nodePath: any, filteredTree: any): any;
-    toggleSelected(tree: any, nodePath: any): void;
-    changeSelectedForChildren(tree: any, parentNodePath: any, changeTo: any, filteredTree: any): any;
-    updateLeafNodeSelection(node: any, changeTo: any): void;
-    /**Calculates visual state based on children  */
-    getVisualState(filteredTree: any, node: any): string;
-    /** recursibly recomputes parent visual state until root */
-    recomputeAllParentVisualState(tree: any, filteredTree: any, nodePath: any): any;
+import type { PropertyHelper } from './property-helper.js';
+import type { TreeHelper } from './tree-helper.js';
+import { SelectionModes, type Node, type NodePath, type Tree } from '../types.js';
+export declare class SelectionHelper {
+    helper: TreeHelper;
+    props: PropertyHelper;
+    recursiveMode: boolean;
+    constructor(treeHelper: TreeHelper, recursive: boolean);
+    private path;
+    isSelected(node: Node): boolean;
+    getSelectableDirectChildren(tree: Tree, parentNodePath: string | null): unknown[];
+    setSelection(tree: Tree, nodePath: NodePath, changeTo: boolean): void;
+    private changeSelectedRecursively;
     /** Computes visual states for all nodes. Used for computing initial visual states when tree changes  */
-    computeInitialVisualStates(tree: any, filteredTree: any): any;
-    /** Recursivly computes visual state for children  */
-    computeChildrenVisualStates(tree: any, filteredTree: any, node: any): any;
-    deleteSelected(tree: any): any;
-    isSelectable(node: any, showCheckboxes: any): boolean;
+    recomputeAllVisualStates(tree: Tree): void;
+    deleteSelected(tree: Tree): void;
+    isSelectable(node: Node, showCheckboxes: SelectionModes): boolean;
+    private computeVisualStates;
+    /** recursibly recomputes parent visual state until root */
+    private recomputeParentVisualState;
+    /**
+     * Computes visual state from leaf to node
+     * @param tree
+     * @param filteredTree
+     * @param node
+     * @returns New visual state for node
+     */
+    private computeVisualStateRecursively;
+    private getVisualState;
 }

package/dist/helpers/selection-helpers.js

@@ -1,182 +1,148 @@
-// @ts-nocheck
-import { checkboxesType, visualStateType } from "../consts";
-
-export class SelectionHelper {
-	constructor(treeHelper) {
-		this.helper = treeHelper;
-		this.props = treeHelper.props;
-	}
-
-	path(node) {
-		return this.helper.path(node);
-	}
-	selected(node) {
-		return node[this.props.selected];
-	}
-
-	getChildrenWithCheckboxes(tree, parentNodePath) {
-		return this.helper
-			.getDirectChildren(tree, parentNodePath)
-			.filter((node) => this.isSelectable(node, checkboxesType.all));
-	}
-
-	changeSelection(tree, nodePath, filteredTree) {
-		this.toggleSelected(tree, nodePath);
-
-		const recursive = this.helper.config?.recursive ?? false;
-
-		if (recursive) {
-			tree = this.recomputeAllParentVisualState(tree, filteredTree, nodePath);
-		}
-
-		return tree;
-	}
-
-	toggleSelected(tree, nodePath) {
-		const node = this.helper.findNode(tree, nodePath);
-
-		node[this.props.selected] = !node[this.props.selected];
-	}
-
-	changeSelectedForChildren(tree, parentNodePath, changeTo, filteredTree) {
-		tree = tree.map((node) => {
-			//changes itself
-			if (parentNodePath == this.path(node)) {
-				this.updateLeafNodeSelection(node, changeTo);
-			}
-
-			if (!parentNodePath) {
-				// TODO i think this isnt working
-				// this only updates
-
-				//top level
-				this.updateLeafNodeSelection(node, changeTo);
-			} else {
-				//if parentNodePath isnt root
-				if (
-					this.path(node).startsWith(parentNodePath.toString()) &&
-					this.path(node) != parentNodePath.toString()
-				) {
-					this.updateLeafNodeSelection(node, changeTo);
-				}
-			}
-			return node;
-		});
-
-		tree = this.recomputeAllParentVisualState(
-			tree,
-			filteredTree,
-			parentNodePath
-		);
-		return tree;
-	}
-
-	//changes selected or visual state depending on
-	updateLeafNodeSelection(node, changeTo) {
-		//dont change if not selectable
-		if (!this.isSelectable(node, checkboxesType.all)) {
-			return;
-		}
-		if (!node[this.props.hasChildren]) {
-			node[this.props.selected] = changeTo;
-		} else {
-			node.__visual_state = changeTo.toString();
-		}
-	}
-
-	/**Calculates visual state based on children  */
-	getVisualState(filteredTree, node) {
-		const children = this.getChildrenWithCheckboxes(
-			filteredTree,
-			this.path(node)
-		);
-
-		if (!children || children?.length == 0) return visualStateType.notSelected;
-
-		//if every child is selected or vs=true return true
-		if (
-			children.every(
-				(x) =>
-					x[this.props.selected] === true ||
-					x.__visual_state === visualStateType.selected
-			)
-		) {
-			return visualStateType.selected;
-		}
-		//at least sone child is selected or indeterminate
-		else if (
-			children.some((x) => {
-				return (
-					x[this.props.selected] === true ||
-					x.__visual_state === visualStateType.indeterminate ||
-					x.__visual_state === visualStateType.selected
-				);
-			})
-		) {
-			return visualStateType.indeterminate;
-		} else {
-			return visualStateType.notSelected;
-		}
-	}
-
-	/** recursibly recomputes parent visual state until root */
-	recomputeAllParentVisualState(tree, filteredTree, nodePath) {
-		const parent = this.helper.getParentNodePath(nodePath);
-
-		let newstate;
-		filteredTree.forEach((x) => {
-			if (this.path(x) == parent) {
-				newstate = this.getVisualState(filteredTree, x);
-				x.__visual_state = newstate;
-			}
-		});
-		if (this.helper.getParentNodePath(parent) != "") {
-			tree = this.recomputeAllParentVisualState(tree, filteredTree, parent);
-		}
-		return tree;
-	}
-
-	/** Computes visual states for all nodes. Used for computing initial visual states when tree changes  */
-	computeInitialVisualStates(tree, filteredTree) {
-		let rootELements = this.getChildrenWithCheckboxes(tree, null);
-		rootELements.forEach((x) => {
-			if (x[this.props.hasChildren] == true) {
-				tree = this.computeChildrenVisualStates(tree, filteredTree, x);
-				x.__visual_state = this.getVisualState(filteredTree, x);
-			}
-		});
-		return tree;
-	}
-	/** Recursivly computes visual state for children  */
-	computeChildrenVisualStates(tree, filteredTree, node) {
-		let children = this.getChildrenWithCheckboxes(tree, this.path(node));
-		//foreaches all children if it has children, it calls itself, then it computes __vs => will compute from childern to parent
-		children.forEach((x) => {
-			if (x[this.props.hasChildren] === true) {
-				tree = this.computeChildrenVisualStates(tree, filteredTree, x);
-				x.__visual_state = this.getVisualState(filteredTree, x);
-			}
-		});
-		return tree;
-	}
-
-	deleteSelected(tree) {
-		return tree.map((node) => {
-			node[this.props.selected] = false;
-			node.__visual_state = undefined;
-			return node;
-		});
-	}
-
-	isSelectable(node, showCheckboxes) {
-		if (showCheckboxes == checkboxesType.all) {
-			return node[this.props.checkbox] !== false;
-		}
-		//show only if pop is true
-		if (showCheckboxes == checkboxesType.perNode) {
-			return node[this.props.checkbox] === true;
-		}
-		//dont show at all
-		return false;
-	}
-}
+import { SelectionModes, VisualStates } from '../types.js';
+export class SelectionHelper {
+    helper;
+    props;
+    recursiveMode;
+    constructor(treeHelper, recursive) {
+        this.helper = treeHelper;
+        this.props = treeHelper.props;
+        this.recursiveMode = recursive;
+    }
+    path(node) {
+        return this.helper.path(node);
+    }
+    isSelected(node) {
+        return (this.props.selected(node) === true || this.props.visualState(node) === VisualStates.selected);
+    }
+    getSelectableDirectChildren(tree, parentNodePath) {
+        return this.helper
+            .getDirectChildren(tree, parentNodePath)
+            .filter((node) => this.isSelectable(node, SelectionModes.all));
+    }
+    setSelection(tree, nodePath, changeTo) {
+        const node = this.helper.findNode(tree, nodePath);
+        // allow selection of root node
+        if ((this.recursiveMode && this.props.hasChildren(node)) || nodePath === null) {
+            this.changeSelectedRecursively(tree, nodePath, changeTo);
+        }
+        else {
+            if (!node) {
+                // throw new Error('Node not found ' + nodePath);
+                console.warn('Node %s doesnt exits', nodePath);
+                return;
+            }
+            this.props.setSelected(node, changeTo);
+        }
+    }
+    changeSelectedRecursively(tree, parentNodePath, changeTo) {
+        tree.forEach((node) => {
+            // match itself and all children
+            if (this.path(node)?.startsWith(parentNodePath ?? '')) {
+                //dont change if not selectable
+                if (!this.isSelectable(node, SelectionModes.all)) {
+                    return;
+                }
+                // in recursive mode only update leaf nodes
+                if (this.recursiveMode && this.props.hasChildren(node)) {
+                    return;
+                }
+                this.props.setSelected(node, changeTo);
+            }
+        });
+    }
+    /** Computes visual states for all nodes. Used for computing initial visual states when tree changes  */
+    recomputeAllVisualStates(tree) {
+        // TODO is this really the case?
+        // if some node is not selectable, are all its children also not selectable?
+        const rootELements = this.getSelectableDirectChildren(tree, null);
+        rootELements.forEach((x) => {
+            if (this.props.hasChildren(x) == true) {
+                const result = this.computeVisualStateRecursively(tree, x);
+                this.props.setVisualState(x, result.state);
+            }
+        });
+    }
+    deleteSelected(tree) {
+        return tree.forEach((node) => {
+            this.props.setSelected(node, false);
+            this.props.setVisualState(node, null);
+        });
+    }
+    isSelectable(node, showCheckboxes) {
+        if (showCheckboxes === SelectionModes.all) {
+            return this.props.checkbox(node) !== false;
+        }
+        //show only if pop is true
+        if (showCheckboxes === SelectionModes.perNode) {
+            return this.props.checkbox(node) === true;
+        }
+        //dont show at all
+        return false;
+    }
+    computeVisualStates(directChildrenVisualStates) {
+        if (!directChildrenVisualStates || directChildrenVisualStates?.length == 0)
+            return VisualStates.selected;
+        //if every child is selected or vs=true return true
+        if (directChildrenVisualStates.every((state) => state === VisualStates.selected)) {
+            return VisualStates.selected;
+        }
+        //at least sone child is selected or indeterminate
+        else if (directChildrenVisualStates.some((state) => state === VisualStates.selected || state === VisualStates.indeterminate)) {
+            return VisualStates.indeterminate;
+        }
+        else {
+            return VisualStates.notSelected;
+        }
+    }
+    /** recursibly recomputes parent visual state until root */
+    recomputeParentVisualState(tree, filteredTree, nodePath) {
+        // no need to recompute state for root
+        if (nodePath === null) {
+            return;
+        }
+        // TODO maybe check that this node have children
+        const parentNode = this.helper.findNode(tree, nodePath);
+        const directChildren = this.helper.getDirectChildren(tree, nodePath);
+        const directChildrenVisualStates = directChildren.map((node) => this.getVisualState(node));
+        const newState = this.computeVisualStates(directChildrenVisualStates);
+        this.props.setVisualState(parentNode, newState);
+        // use recursion, because we need to traverse from node to root
+        const ParentPath = this.helper.getParentNodePath(nodePath);
+        this.recomputeParentVisualState(tree, filteredTree, ParentPath);
+    }
+    /**
+     * Computes visual state from leaf to node
+     * @param tree
+     * @param filteredTree
+     * @param node
+     * @returns New visual state for node
+     */
+    computeVisualStateRecursively(tree, node) {
+        const directChildren = this.getSelectableDirectChildren(tree, this.path(node));
+        const directChildrenStates = [];
+        // using recustion compute from leaft nodes to root
+        directChildren.forEach((child) => {
+            if (!this.props.hasChildren(child)) {
+                const childState = this.isSelected(child)
+                    ? VisualStates.selected
+                    : VisualStates.notSelected;
+                directChildrenStates.push(childState);
+                return;
+            }
+            const result = this.computeVisualStateRecursively(tree, child);
+            this.props.setVisualState(child, result.state);
+            if (!result.ignore) {
+                directChildrenStates.push(result.state);
+            }
+        });
+        // if no children, all are selected, but dont count it for recursive computationq
+        const ignore = directChildrenStates.length === 0;
+        return { ignore, state: this.computeVisualStates(directChildrenStates) };
+    }
+    getVisualState(node) {
+        if (this.props.hasChildren(node)) {
+            return this.props.visualState(node) ?? VisualStates.notSelected;
+        }
+        return this.isSelected(node) ? VisualStates.selected : VisualStates.notSelected;
+    }
+}

package/dist/helpers/tree-helper.d.ts

@@ -1,33 +1,34 @@
-export class TreeHelper {
-    constructor(propNames: any, config?: {});
-    props: any;
-    config: {};
+import { SelectionHelper } from './selection-helpers.js';
+import { DragAndDropHelper } from './drag-drop-helpers.js';
+import type { Node, NodePath, HelperConfig } from '../types.js';
+import type { PropertyHelper } from './property-helper.js';
+export declare class TreeHelper {
+    props: PropertyHelper;
+    config: HelperConfig;
     selection: SelectionHelper;
     dragDrop: DragAndDropHelper;
-    path(node: any): any;
-    getParentNodePath(nodePath: any): any;
-    hasChildren(tree: any, nodePath: any): any;
-    findNode(tree: any, nodePath: any): any;
-    nodePathIsChild(nodePath: any): any;
-    getDirectChildren(tree: any, parentNodePath: any): any;
-    allCHildren(tree: any, parentNodePath: any): any;
-    getAllLeafNodes(tree: any): any;
-    joinTrees(filteredTree: any, tree: any): any;
-    mergeTrees(oldTree: any, addedTree: any, nodePath?: string): any;
+    constructor(props: PropertyHelper, config?: HelperConfig);
+    path(node: Node | null): NodePath;
+    getParentNodePath(nodePath: NodePath): NodePath;
+    isChildrenOf(parentNodePath: NodePath, childrenNodePath: NodePath): boolean | undefined;
+    hasChildren(tree: Node[], nodePath: NodePath): unknown;
+    findNode(tree: Node[], nodePath: NodePath): Node;
+    nodePathIsChild(nodePath: NodePath): boolean | undefined;
+    getDirectChildren(tree: Node[], parentNodePath: NodePath): unknown[];
+    allCHildren(tree: Node[], parentNodePath: NodePath): unknown[];
+    getAllLeafNodes(tree: Node[]): unknown[];
+    joinTrees(filteredTree: Node[], tree: Node[]): unknown[];
+    mergeTrees(oldTree: Node[], addedTree: Node[], nodePath?: string): unknown[];
     /** toggles expansion on
      */
-    changeExpansion(tree: any, node: any, changeTo: any): void;
+    changeExpansion(tree: Node[], node: Node, changeTo: boolean): void;
     /** changes expansion of every node that has this.hasChildren set to true
      */
-    changeEveryExpansion(tree: any, changeTo: any): any;
+    changeEveryExpansion(tree: Node[], changeTo: boolean): unknown[];
     /** changes expansion of every node that has this.hasChildren set to true if they are abose set level and expansion property isnt set
      */
-    expandToLevel(tree: any, level: any): any;
-    getDepthLevel(nodePath: any): number;
-    searchTree(tree: any, filter: any, leafesOnly: any): any;
-    getParents(tree: any, node: any): any;
+    expandToLevel(tree: Node[], level: number): unknown[];
+    getDepthLevel(nodePath: NodePath): number;
+    searchTree(tree: Node[], filter: (node: unknown) => boolean): unknown[];
+    getParents(tree: Node[], node: Node): unknown[];
 }
-declare function _default(...args: any[]): TreeHelper;
-export default _default;
-import { SelectionHelper } from './selection-helpers';
-import { DragAndDropHelper } from './drag-drop-helpers';