@mantine/core/cjs/components/Tree/use-tree.cjs

React components library focused on usability, accessibility and developer experience

"use client";
require("../../_virtual/_rolldown/runtime.cjs");
const require_get_all_checked_nodes = require("./get-all-checked-nodes/get-all-checked-nodes.cjs");
const require_get_children_nodes_values = require("./get-children-nodes-values/get-children-nodes-values.cjs");
const require_is_node_checked = require("./is-node-checked/is-node-checked.cjs");
const require_is_node_indeterminate = require("./is-node-indeterminate/is-node-indeterminate.cjs");
let react = require("react");
let _mantine_hooks = require("@mantine/hooks");
//#region packages/@mantine/core/src/components/Tree/use-tree.ts
function getInitialTreeExpandedState(initialState, data, value, acc = {}) {
	data.forEach((node) => {
		acc[node.value] = node.value in initialState ? initialState[node.value] : node.value === value;
		if (Array.isArray(node.children)) getInitialTreeExpandedState(initialState, node.children, value, acc);
	});
	return acc;
}
function getTreeExpandedState(data, expandedNodesValues) {
	const state = getInitialTreeExpandedState({}, data, []);
	if (expandedNodesValues === "*") return Object.keys(state).reduce((acc, key) => ({
		...acc,
		[key]: true
	}), {});
	expandedNodesValues.forEach((node) => {
		state[node] = true;
	});
	return state;
}
function getInitialCheckedState(initialState, data) {
	const acc = [];
	initialState.forEach((node) => acc.push(...require_get_children_nodes_values.getChildrenNodesValues(node, data)));
	return Array.from(new Set(acc));
}
function useTree({ initialSelectedState = [], expandedState, initialCheckedState = [], checkedState, initialExpandedState = {}, selectedState, multiple = false, onNodeCollapse, onNodeExpand, onCheckedStateChange, onSelectedStateChange, onExpandedStateChange } = {}) {
	const [data, setData] = (0, react.useState)([]);
	const [_expandedState, setExpandedState] = (0, _mantine_hooks.useUncontrolled)({
		value: expandedState,
		defaultValue: initialExpandedState,
		finalValue: {},
		onChange: onExpandedStateChange
	});
	const [_selectedState, setSelectedState] = (0, _mantine_hooks.useUncontrolled)({
		value: selectedState,
		defaultValue: initialSelectedState,
		finalValue: [],
		onChange: onSelectedStateChange
	});
	const [_checkedState, setCheckedState] = (0, _mantine_hooks.useUncontrolled)({
		value: checkedState,
		defaultValue: initialCheckedState,
		finalValue: [],
		onChange: onCheckedStateChange
	});
	const [anchorNode, setAnchorNode] = (0, react.useState)(null);
	const initialize = (0, react.useCallback)((_data) => {
		setExpandedState(getInitialTreeExpandedState(_expandedState, _data, _selectedState));
		setCheckedState(getInitialCheckedState(_checkedState, _data));
		setData(_data);
	}, [
		_selectedState,
		_checkedState,
		_expandedState
	]);
	const toggleExpanded = (0, react.useCallback)((value) => {
		const nextState = {
			..._expandedState,
			[value]: !_expandedState[value]
		};
		nextState[value] ? onNodeExpand?.(value) : onNodeCollapse?.(value);
		setExpandedState(nextState);
	}, [
		onNodeCollapse,
		onNodeExpand,
		_expandedState
	]);
	const collapse = (0, react.useCallback)((value) => {
		if (_expandedState[value] !== false) onNodeCollapse?.(value);
		setExpandedState({
			..._expandedState,
			[value]: false
		});
	}, [onNodeCollapse, _expandedState]);
	const expand = (0, react.useCallback)((value) => {
		if (_expandedState[value] !== true) onNodeExpand?.(value);
		setExpandedState({
			..._expandedState,
			[value]: true
		});
	}, [onNodeExpand, _expandedState]);
	const expandAllNodes = (0, react.useCallback)(() => {
		const nextState = { ..._expandedState };
		Object.keys(nextState).forEach((key) => {
			nextState[key] = true;
		});
		setExpandedState(nextState);
	}, [_expandedState]);
	const collapseAllNodes = (0, react.useCallback)(() => {
		const nextState = { ..._expandedState };
		Object.keys(nextState).forEach((key) => {
			nextState[key] = false;
		});
		setExpandedState(nextState);
	}, [_expandedState]);
	const toggleSelected = (0, react.useCallback)((value) => {
		if (!multiple) {
			if (_selectedState.includes(value)) {
				setAnchorNode(null);
				return [];
			}
			setAnchorNode(value);
			return [value];
		}
		if (_selectedState.includes(value)) {
			setAnchorNode(null);
			return _selectedState.filter((item) => item !== value);
		}
		setAnchorNode(value);
		setSelectedState([..._selectedState, value]);
	}, [_selectedState]);
	const select = (0, react.useCallback)((value) => {
		setAnchorNode(value);
		setSelectedState(multiple ? _selectedState.includes(value) ? _selectedState : [..._selectedState, value] : [value]);
	}, [_selectedState]);
	const deselect = (0, react.useCallback)((value) => {
		anchorNode === value && setAnchorNode(null);
		setSelectedState(_selectedState.filter((item) => item !== value));
	}, [_selectedState]);
	const clearSelected = (0, react.useCallback)(() => {
		setSelectedState([]);
		setAnchorNode(null);
	}, []);
	const checkNode = (0, react.useCallback)((value) => {
		const checkedNodes = require_get_children_nodes_values.getChildrenNodesValues(value, data);
		setCheckedState(Array.from(new Set([..._checkedState, ...checkedNodes])));
	}, [data, _checkedState]);
	const uncheckNode = (0, react.useCallback)((value) => {
		const checkedNodes = require_get_children_nodes_values.getChildrenNodesValues(value, data);
		setCheckedState(_checkedState.filter((item) => !checkedNodes.includes(item)));
	}, [data, _checkedState]);
	const checkAllNodes = (0, react.useCallback)(() => {
		setCheckedState(require_get_children_nodes_values.getAllChildrenNodes(data));
	}, [data]);
	const uncheckAllNodes = (0, react.useCallback)(() => {
		setCheckedState([]);
	}, []);
	const getCheckedNodes = () => require_get_all_checked_nodes.getAllCheckedNodes(data, _checkedState).result;
	const isNodeChecked = (value) => require_is_node_checked.memoizedIsNodeChecked(value, data, _checkedState);
	const isNodeIndeterminate = (value) => require_is_node_indeterminate.memoizedIsNodeIndeterminate(value, data, _checkedState);
	return {
		multiple,
		expandedState: _expandedState,
		selectedState: _selectedState,
		checkedState: _checkedState,
		anchorNode,
		initialize,
		toggleExpanded,
		collapse,
		expand,
		expandAllNodes,
		collapseAllNodes,
		setExpandedState,
		checkNode,
		uncheckNode,
		checkAllNodes,
		uncheckAllNodes,
		setCheckedState,
		toggleSelected,
		select,
		deselect,
		clearSelected,
		setSelectedState,
		getCheckedNodes,
		isNodeChecked,
		isNodeIndeterminate
	};
}
//#endregion
exports.getTreeExpandedState = getTreeExpandedState;
exports.useTree = useTree;

//# sourceMappingURL=use-tree.cjs.map