@mezzanine-ui/react 1.0.0-beta.6 → 1.0.0-beta.7

package/Select/TreeSelect.js

@@ -1,205 +0,0 @@
-'use client';
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { selectClasses } from '@mezzanine-ui/core/select';
-import { forwardRef, useContext, useMemo, useRef, useState } from 'react';
-import { useClickAway } from '../hooks/useClickAway.js';
-import { useComposeRefs } from '../hooks/useComposeRefs.js';
-import { useIsomorphicLayoutEffect } from '../hooks/useIsomorphicLayoutEffect.js';
-import SelectTrigger from './SelectTrigger.js';
-import { FormControlContext } from '../Form/FormControlContext.js';
-import { traverseTree } from '../Tree/traverseTree.js';
-import InputTriggerPopper from '../_internal/InputTriggerPopper/InputTriggerPopper.js';
-import Menu from '../Menu/Menu.js';
-import Tree from '../Tree/Tree.js';
-import { toggleValue } from '../Tree/toggleValue.js';
-import cx from 'clsx';
-
-const TreeSelect = forwardRef((props, ref) => {
-    var _a;
-    const { disabled: disabledFromFormControl, fullWidth: fullWidthFromFormControl, required: requiredFromFormControl, severity, } = useContext(FormControlContext) || {};
-    const { className, clearable = false, defaultExpandAll, depth, disabled = disabledFromFormControl || false, disabledValues, error = severity === 'error' || false, expandControllerRef, fullWidth = fullWidthFromFormControl || false, inputProps, inputRef, itemsInView = 4, menuMaxHeight, menuProps, menuRole = 'listbox', menuSize, mode = 'single', onBlur, onChange: onChangeProp, onExpand: onExpandProp, onFocus, options, placeholder = '', popperOptions, prefix, renderValue, required = requiredFromFormControl || false, sameWidth = false, size, suffixActionIcon, treeProps, value: valueProp, } = props;
-    const { className: treeClassName, ...restTreeProps } = treeProps || {};
-    const { width, border, ...restStyle } = (menuProps === null || menuProps === void 0 ? void 0 : menuProps.style) || {};
-    const multiple = mode === 'multiple';
-    /** Compute panel width */
-    const panelWidth = useMemo(() => {
-        if (width) {
-            return;
-        }
-        const base = multiple ? 224 : 208;
-        const indent = 16;
-        function getWidth(resultDepth) {
-            return (resultDepth - 1) * indent + base;
-        }
-        if (depth) {
-            return getWidth(depth);
-        }
-        function maxDepth(object, counter = 1) {
-            if (object.siblings) {
-                return Math.max(...object.siblings.map((sibling) => maxDepth(sibling, counter + 1)));
-            }
-            return counter;
-        }
-        const computedMaxDepth = options.reduce((acc, current) => {
-            const currentDepth = maxDepth(current);
-            return currentDepth > acc ? currentDepth : acc;
-        }, 0);
-        return getWidth(computedMaxDepth);
-    }, [depth, multiple, options, width]);
-    /** Popper positioning */
-    const nodeRef = useRef(null);
-    const controlRef = useRef(null);
-    const popperRef = useRef(null);
-    const composedRef = useComposeRefs([ref, controlRef]);
-    /** Make popper positioning dynamically by computing styles every time value prop changes */
-    const controllerRef = useRef(null);
-    useIsomorphicLayoutEffect(() => {
-        var _a, _b;
-        (_b = (_a = controllerRef.current) === null || _a === void 0 ? void 0 : _a.update) === null || _b === void 0 ? void 0 : _b.call(_a);
-    }, [valueProp]);
-    /** Open control */
-    const [open, toggleOpen] = useState(false);
-    const onOpen = () => {
-        onFocus === null || onFocus === void 0 ? void 0 : onFocus();
-        toggleOpen(true);
-    };
-    const onClose = () => {
-        onBlur === null || onBlur === void 0 ? void 0 : onBlur();
-        toggleOpen(false);
-    };
-    const onToggleOpen = () => {
-        if (open) {
-            onClose();
-        }
-        else {
-            onOpen();
-        }
-    };
-    const onTextFieldClick = disabled
-        ? undefined
-        : () => {
-            onToggleOpen();
-        };
-    const onTextFieldKeydown = disabled
-        ? undefined
-        : (event) => {
-            switch (event.code) {
-                case 'Enter':
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    onTextFieldClick();
-                    break;
-                case 'ArrowUp':
-                case 'ArrowRight':
-                case 'ArrowLeft':
-                case 'ArrowDown': {
-                    if (!open) {
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        onTextFieldClick();
-                    }
-                    break;
-                }
-                case 'Tab': {
-                    if (open) {
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        onTextFieldClick();
-                    }
-                    break;
-                }
-            }
-        };
-    useClickAway(() => {
-        if (!open)
-            return;
-        return (event) => {
-            var _a;
-            if (!((_a = popperRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target))) {
-                onClose();
-            }
-        };
-    }, controlRef, [open, toggleOpen]);
-    /** Trigger input props */
-    const resolvedInputProps = {
-        ...inputProps,
-        'aria-expanded': open,
-        placeholder,
-        role: 'combobox',
-    };
-    /** Tags close handler */
-    const onTagClose = onChangeProp && valueProp
-        ? (target) => {
-            onChangeProp(valueProp.filter((v) => v.id !== target.id));
-        }
-        : undefined;
-    /** Clear method */
-    const onClear = clearable && onChangeProp
-        ? () => {
-            onChangeProp([]);
-        }
-        : undefined;
-    /** Map options to tree nodes */
-    function mapOptionToNode(option) {
-        var _a;
-        return {
-            label: option.name,
-            value: option.id,
-            dynamicNodesFetching: option.dynamicChildrenFetching,
-            nodes: (_a = option.siblings) === null || _a === void 0 ? void 0 : _a.map((sibling) => mapOptionToNode(sibling)),
-        };
-    }
-    function flattenOptions(targets) {
-        const optionsMap = {};
-        function mapOptionsToSelectValue(optionsToMap) {
-            optionsToMap.forEach((optionToMap) => {
-                optionsMap[optionToMap.id] = {
-                    id: optionToMap.id,
-                    name: optionToMap.name,
-                };
-                if (optionToMap.siblings) {
-                    mapOptionsToSelectValue(optionToMap.siblings);
-                }
-            });
-        }
-        mapOptionsToSelectValue(targets);
-        return optionsMap;
-    }
-    const optionMap = flattenOptions(options);
-    const nodes = options.map((option) => mapOptionToNode(option));
-    /** Map selected values */
-    const selectedValues = valueProp === null || valueProp === void 0 ? void 0 : valueProp.map((v) => mapOptionToNode(v).value);
-    const onSelect = onChangeProp
-        ? (values) => {
-            const selectValues = values.map((currentValue) => optionMap[currentValue]);
-            onChangeProp(selectValues);
-        }
-        : undefined;
-    /** Controlled expanded value to avoid expanded values cleanup after panel toggled */
-    const [expandedValues, setExpandedValues] = useState(() => {
-        const currentExpandedValues = [];
-        if (defaultExpandAll) {
-            traverseTree(nodes, (node) => {
-                if (node.nodes) {
-                    currentExpandedValues.push(node.value);
-                }
-            });
-        }
-        return currentExpandedValues;
-    });
-    const onExpand = (value) => {
-        const newExpandedValues = toggleValue(value, expandedValues);
-        setExpandedValues(newExpandedValues);
-        onExpandProp === null || onExpandProp === void 0 ? void 0 : onExpandProp(value);
-    };
-    // Convert valueProp to single value for single mode
-    const triggerValue = multiple ? valueProp : ((_a = valueProp === null || valueProp === void 0 ? void 0 : valueProp[0]) !== null && _a !== void 0 ? _a : undefined);
-    // Adapt renderValue for single mode
-    const adaptedRenderValue = renderValue && !multiple
-        ? (value) => renderValue(value !== null && value !== void 0 ? value : null)
-        : undefined;
-    return (jsxs("div", { ref: nodeRef, className: selectClasses.treeSelect, children: [jsx(SelectTrigger, { ref: composedRef, active: open, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputProps: resolvedInputProps, inputRef: inputRef, mode: mode, onClear: onClear, onClick: onTextFieldClick, onKeyDown: onTextFieldKeydown, onTagClose: onTagClose, prefix: prefix, readOnly: true, ...(mode === 'single' && adaptedRenderValue ? { renderValue: adaptedRenderValue } : {}), required: required, size: size, suffixActionIcon: suffixActionIcon, value: triggerValue }), jsx(InputTriggerPopper, { ref: popperRef, anchor: controlRef, className: selectClasses.popper, controllerRef: controllerRef, open: open, options: popperOptions, sameWidth: sameWidth, children: jsx(Menu, { itemsInView: itemsInView, maxHeight: menuMaxHeight, role: menuRole, size: menuSize, style: {
-                        ...restStyle,
-                        border: border || 0,
-                        width: width || `${panelWidth}px`,
-                    }, children: jsx(Tree, { ...restTreeProps, ref: ref, className: cx(selectClasses.tree, treeClassName), disabledValues: disabledValues, expandControllerRef: expandControllerRef, expandedValues: expandedValues, multiple: multiple, nodes: nodes, onExpand: onExpand, onSelect: onSelect, selectMethod: "target", selectable: true, values: selectedValues }) }) })] }));
-});
-
-export { TreeSelect as default };

package/Tree/Tree.d.ts

@@ -1,70 +0,0 @@
-import { TreeNodeValue, TreeSelectMethod } from '@mezzanine-ui/core/tree';
-import { Ref } from 'react';
-import { GetTreeNodeEntitiesProps } from './getTreeNodeEntities';
-import { TreeNodeListElementProps, TreeNodeListProps } from './TreeNodeList';
-import { TreeExpandControl, TreeNodeProp } from './typings';
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-export interface TreeProps extends Pick<TreeNodeListProps, 'multiple' | 'selectable' | 'size' | 'treeNodeProps' | 'treeNodeRefs' | 'onExpand'>, Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'children' | 'defaultChecked' | 'defaultValue' | 'onChange' | 'onSelect'> {
-    /**
-     * Controls whether to expand all at first render.
-     */
-    defaultExpandAll?: boolean;
-    /**
-     * Provide if certain nodes should be disabled.
-     * Notice that there are two conditions for auto disabling.
-     * First, if the siblings are all disabled, the parent will be disabled as well.
-     * Second, if the parent is disabled, all its siblings will be disabled as well.
-     */
-    disabledValues?: GetTreeNodeEntitiesProps['disabledValues'];
-    /**
-     * Provide if access to expand control is needed.
-     */
-    expandControllerRef?: Ref<TreeExpandControl | null>;
-    /**
-     * By default expanded values of `Tree` is uncontrolled.
-     * However, you may specify `expandedValues` to gain full control.
-     * If that's the case, you should provide `onExpand` as well.
-     * Notices that if `expandedValues` is provided, `expandControllerRef` will not get the control methods.
-     */
-    expandedValues?: TreeNodeValue[];
-    /**
-     * By default Tree only passes the leaf values to the select handler.
-     * If you want to include all the node values, set `includeNodeValue` to `true`.
-     */
-    includeNodeValue?: GetTreeNodeEntitiesProps['includeNodeValue'];
-    /**
-     * The nodes to be rendered in `Tree`
-     */
-    nodes: TreeNodeProp[];
-    /**
-     * By default expanded values of `Tree` is uncontrolled, where `onExpand` is not needed.
-     * However, you may specify `expandedValues` to gain full control
-     * and that's where you should provide `onExpand` together.
-     */
-    onExpand?: TreeNodeListProps['onExpand'];
-    /**
-     * Select handler for `Tree`. Receives all the current selected values as its argument.
-     */
-    onSelect?: (selectedValues: TreeNodeValue[]) => void;
-    /**
-     * Controls the singular select logic.
-     * `Toggle` means the value will be toggled.
-     * `Target` means the target value will always be the result value and will not deselect if click again.
-     * @default 'toggle''
-     */
-    selectMethod?: TreeSelectMethod;
-    /**
-     * Other `ul` props you may provide to `TreeNodeList` component.
-     * A common use-case is to override classes and styles.
-     */
-    treeNodeListProps?: TreeNodeListElementProps;
-    /**
-     * The selected values are controlled values. Should be use with `selectable`.
-     */
-    values?: TreeNodeValue | TreeNodeValue[];
-}
-/**
- * The react component for `mezzanine` tree.
- */
-declare const Tree: import("react").ForwardRefExoticComponent<TreeProps & import("react").RefAttributes<HTMLDivElement>>;
-export default Tree;

package/Tree/Tree.js

@@ -1,139 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { treeClasses } from '@mezzanine-ui/core/tree';
-import { forwardRef, useMemo, useImperativeHandle } from 'react';
-import castArray from 'lodash/castArray';
-import without from 'lodash/without';
-import uniq from 'lodash/uniq';
-import { getTreeNodeEntities } from './getTreeNodeEntities.js';
-import { toggleValueWithStatusControl } from './toggleValue.js';
-import { traverseTree } from './traverseTree.js';
-import TreeNodeList from './TreeNodeList.js';
-import { useTreeExpandedValue } from './useTreeExpandedValue.js';
-import cx from 'clsx';
-
-/**
- * The react component for `mezzanine` tree.
- */
-const Tree = forwardRef(function Tree(props, ref) {
-    const { className, defaultExpandAll, disabledValues, expandControllerRef, expandedValues: expandedValuesProp, includeNodeValue, multiple, nodes, onExpand: onExpandProp, onSelect: onSelectProp, selectMethod = 'toggle', selectable, size, treeNodeListProps, treeNodeProps, treeNodeRefs, values, ...restRootProp } = props;
-    const selectedValues = values
-        ? castArray(values)
-        : undefined;
-    const { expandedValues, onExpand, setExpandedValues } = useTreeExpandedValue({
-        nodes,
-        defaultExpandAll,
-        expandedValues: expandedValuesProp,
-        onExpand: onExpandProp,
-    });
-    const treeEntities = useMemo(() => getTreeNodeEntities({
-        disabledValues,
-        expandedValues,
-        includeNodeValue,
-        multiple,
-        nodes,
-        selectedValues,
-    }), [
-        disabledValues,
-        expandedValues,
-        includeNodeValue,
-        multiple,
-        nodes,
-        selectedValues,
-    ]);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const displayNodes = nodes.map((node) => treeEntities.get(node.value).node);
-    const getAllExpandSiblingValues = (value) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const currentEntity = treeEntities.get(value);
-        const allSiblingEntities = currentEntity.siblings;
-        const allSiblingNodes = allSiblingEntities === null || allSiblingEntities === void 0 ? void 0 : allSiblingEntities.map(({ node }) => node);
-        const allNodeValues = [];
-        if (allSiblingNodes === null || allSiblingNodes === void 0 ? void 0 : allSiblingNodes.length) {
-            allNodeValues.push(currentEntity.node.value);
-            traverseTree(allSiblingNodes, (node) => {
-                var _a;
-                if ((_a = node.nodes) === null || _a === void 0 ? void 0 : _a.length) {
-                    allNodeValues.push(node.value);
-                }
-            });
-        }
-        return allNodeValues;
-    };
-    const collapse = (value) => {
-        setExpandedValues(expandedValues.filter((v) => v !== value));
-    };
-    const collapseAll = () => {
-        const allNodeValues = nodes.reduce((acc, currentNode) => [
-            ...acc,
-            ...getAllExpandSiblingValues(currentNode.value),
-        ], []);
-        const uniqAllNodeValues = uniq(allNodeValues);
-        const newExpandedValues = without(expandedValues, ...uniqAllNodeValues);
-        setExpandedValues(newExpandedValues);
-    };
-    const collapseAllFrom = (value) => {
-        const allNodeValues = getAllExpandSiblingValues(value);
-        const newExpandedValues = without(expandedValues, ...allNodeValues);
-        setExpandedValues(newExpandedValues);
-    };
-    const expand = (value) => {
-        setExpandedValues(uniq([...expandedValues, value]));
-    };
-    const expandAll = () => {
-        const allNodeValues = nodes.reduce((acc, currentNode) => [
-            ...acc,
-            ...getAllExpandSiblingValues(currentNode.value),
-        ], []);
-        const newExpandedValues = uniq([...expandedValues, ...allNodeValues]);
-        setExpandedValues(newExpandedValues);
-    };
-    const expandAllFrom = (value) => {
-        const allNodeValues = getAllExpandSiblingValues(value);
-        const newExpandedValues = uniq([...expandedValues, ...allNodeValues]);
-        setExpandedValues(newExpandedValues);
-    };
-    useImperativeHandle(expandControllerRef, () => {
-        if (expandedValuesProp) {
-            return null;
-        }
-        return {
-            collapse,
-            collapseAll,
-            collapseAllFrom,
-            expand,
-            expandAll,
-            expandAllFrom,
-        };
-    });
-    const onMultipleSelect = onSelectProp
-        ? (value) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const targetEntity = treeEntities.get(value);
-            const { selected } = targetEntity.node;
-            const newCheckedValues = toggleValueWithStatusControl(!!selected, targetEntity.values, selectedValues || []);
-            onSelectProp(newCheckedValues);
-        }
-        : undefined;
-    const onSingleSelect = onSelectProp
-        ? (value) => {
-            var _a;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const targetEntity = treeEntities.get(value);
-            const { selected } = targetEntity.node;
-            if (!((_a = targetEntity.siblings) === null || _a === void 0 ? void 0 : _a.length)) {
-                if (selectMethod === 'target') {
-                    onSelectProp([value]);
-                }
-                else {
-                    const newCheckedValues = toggleValueWithStatusControl(!!selected, targetEntity.values, []);
-                    onSelectProp(newCheckedValues);
-                }
-            }
-        }
-        : undefined;
-    const selectHandler = multiple ? onMultipleSelect : onSingleSelect;
-    const onSelect = selectable ? selectHandler : undefined;
-    return (jsx("div", { ref: ref, className: cx(treeClasses.host, className), ...restRootProp, children: jsx(TreeNodeList, { ...treeNodeListProps, multiple: multiple, nodes: displayNodes, onExpand: onExpand, onSelect: onSelect, selectable: selectable, size: size, treeNodeProps: treeNodeProps, treeNodeRefs: treeNodeRefs }) }));
-});
-
-export { Tree as default };

package/Tree/TreeNode.d.ts

@@ -1,40 +0,0 @@
-import { TreeNodeValue, TreeSize } from '@mezzanine-ui/core/tree';
-import { CollapseProps } from '../Transition';
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-import { TreeNodeData } from './typings';
-export type TreeNodeElementProps = Omit<NativeElementPropsWithoutKeyAndRef<'li'>, 'children' | 'value' | 'onSelect'>;
-export interface TreeNodeProps extends TreeNodeData, TreeNodeElementProps {
-    /**
-     * Provided children will be wrapped under `Collapse`.
-     */
-    children?: CollapseProps['children'];
-    /**
-     * The list item will be rendered as `Checkbox` if multiple set to true.
-     * @default false
-     */
-    multiple?: boolean;
-    /**
-     * Handler for caret icon click event. Receive current node value as its argument.
-     */
-    onExpand?: (value: TreeNodeValue) => void;
-    /**
-     * Handler for label element click event. Receive current node value as its argument.
-     * Must use with selectable setting to `true`.
-     */
-    onSelect?: (value: TreeNodeValue) => void;
-    /**
-     * Controls whether to be selectable.
-     * @default false
-     */
-    selectable?: boolean;
-    /**
-     * Sizes for the layout.
-     * @default 'medium'
-     */
-    size?: TreeSize;
-}
-/**
- * The react component for `mezzanine` tree node.
- */
-declare const TreeNode: import("react").ForwardRefExoticComponent<TreeNodeProps & import("react").RefAttributes<HTMLLIElement>>;
-export default TreeNode;

package/Tree/TreeNode.js

@@ -1,50 +0,0 @@
-'use client';
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { treeClasses } from '@mezzanine-ui/core/tree';
-import { CaretRightIcon } from '@mezzanine-ui/icons';
-import { forwardRef, useContext, useMemo } from 'react';
-import { MezzanineConfig } from '../Provider/context.js';
-import Spin from '../Spin/Spin.js';
-import Typography from '../Typography/Typography.js';
-import Icon from '../Icon/Icon.js';
-import Checkbox from '../Checkbox/Checkbox.js';
-import Collapse from '../Transition/Collapse.js';
-import cx from 'clsx';
-
-/**
- * The react component for `mezzanine` tree node.
- */
-const TreeNode = forwardRef(function TreeNode(props, ref) {
-    const { size: globalSize } = useContext(MezzanineConfig);
-    const { children, className, disabled, dynamicNodesFetching, expanded, indeterminate, label, multiple = false, onExpand: onExpandProp, onSelect: onSelectProp, selectable = false, selected, size = globalSize, value, ...restRootProps } = props;
-    const variant = useMemo(() => {
-        if (size === 'small') {
-            return 'input';
-        }
-        if (size === 'large') {
-            return 'input';
-        }
-        return 'input';
-    }, [size]);
-    const onExpand = onExpandProp
-        ? () => {
-            onExpandProp(value);
-        }
-        : undefined;
-    const onSelect = selectable && onSelectProp && !disabled
-        ? () => {
-            onSelectProp(value);
-        }
-        : undefined;
-    const mayHaveChildren = children || dynamicNodesFetching;
-    return (jsxs("li", { ref: ref, ...restRootProps, className: cx(treeClasses.node, treeClasses.nodeSize(size), className), children: [jsxs("div", { className: treeClasses.nodeStem, children: [mayHaveChildren ? (jsx(Icon, { icon: CaretRightIcon, className: cx(treeClasses.nodeCaret, {
-                            [treeClasses.nodeCaretExpanded]: expanded,
-                        }), role: "button", onClick: onExpand })) : (jsx("div", {})), multiple ? (jsx(Checkbox, { checked: !!selected, disabled: disabled, indeterminate: indeterminate, onChange: onSelect, value: `${value}`, children: label })) : (jsx(Typography, { component: "span", variant: variant, onClick: onSelect, className: cx(treeClasses.nodeLabel, {
-                            [treeClasses.nodeLabelSelectable]: !children && selectable,
-                            [treeClasses.nodeLabelIndeterminate]: indeterminate,
-                            [treeClasses.nodeLabelActive]: selected,
-                            [treeClasses.nodeLabelDisabled]: disabled,
-                        }), children: label }))] }), mayHaveChildren && (jsx(Collapse, { in: expanded, appear: false, children: children || jsx(Spin, { loading: true, iconProps: { size: 16 } }) }))] }));
-});
-
-export { TreeNode as default };

package/Tree/TreeNodeList.d.ts

@@ -1,24 +0,0 @@
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-import { TreeNodeElementProps, TreeNodeProps } from './TreeNode';
-import { TreeNodeData, TreeNodeRefs } from './typings';
-export type TreeNodeListElementProps = Omit<NativeElementPropsWithoutKeyAndRef<'ul'>, 'children' | 'onSelect'>;
-export interface TreeNodeListProps extends TreeNodeListElementProps, Pick<TreeNodeProps, 'multiple' | 'onExpand' | 'onSelect' | 'selectable' | 'size'> {
-    /**
-     * Given nodes will be passed to `TreeNode` component orderly.
-     */
-    nodes?: TreeNodeData['nodes'];
-    /**
-     * Other props you may provide to `TreeNode` component. A common use-case is to override classes and styles.
-     */
-    treeNodeProps?: TreeNodeElementProps;
-    /**
-     * Provide if you want to access every list element. Paired with node key and the element.
-     * Usage example: `const treeNodeRefs = useRef<TreeNodeRefsShape | undefined>(undefined)`
-     */
-    treeNodeRefs?: TreeNodeRefs;
-}
-/**
- * The react component for `mezzanine` tree node list.
- */
-declare const TreeNodeList: import("react").ForwardRefExoticComponent<TreeNodeListProps & import("react").RefAttributes<HTMLUListElement>>;
-export default TreeNodeList;

package/Tree/TreeNodeList.js

@@ -1,28 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { treeClasses } from '@mezzanine-ui/core/tree';
-import { forwardRef } from 'react';
-import TreeNode from './TreeNode.js';
-import cx from 'clsx';
-
-/**
- * The react component for `mezzanine` tree node list.
- */
-const TreeNodeList = forwardRef((props, ref) => {
-    const { className, multiple, nodes, onExpand, onSelect, selectable, size = 'medium', treeNodeProps, treeNodeRefs, ...restRootProp } = props;
-    const getNodeRefHandler = treeNodeRefs
-        ? (value) => (node) => {
-            treeNodeRefs.current = {
-                ...treeNodeRefs.current,
-                [value]: node,
-            };
-        }
-        : undefined;
-    if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length))
-        return null;
-    return (jsx("ul", { ...restRootProp, ref: ref, className: cx(treeClasses.nodeList, treeClasses.nodeListSize(size), className), children: nodes.map((node) => {
-            const { value, nodes: siblingNodes, ...restNodeProps } = node;
-            return (jsx(TreeNode, { ref: getNodeRefHandler === null || getNodeRefHandler === void 0 ? void 0 : getNodeRefHandler(value), ...treeNodeProps, multiple: multiple, onExpand: onExpand, onSelect: onSelect, selectable: selectable, size: size, value: value, ...restNodeProps, children: (siblingNodes === null || siblingNodes === void 0 ? void 0 : siblingNodes.length) ? (jsx(TreeNodeList, { ...restRootProp, className: className, multiple: multiple, nodes: siblingNodes, onExpand: onExpand, onSelect: onSelect, selectable: selectable, size: size, treeNodeRefs: treeNodeRefs })) : undefined }, value));
-        }) }));
-});
-
-export { TreeNodeList as default };

package/Tree/getTreeNodeEntities.d.ts

@@ -1,11 +0,0 @@
-import { TreeNodeValue } from '@mezzanine-ui/core/tree';
-import { TreeNodeData, TreeNodeEntities } from './typings';
-export interface GetTreeNodeEntitiesProps {
-    disabledValues?: TreeNodeValue[];
-    expandedValues?: TreeNodeValue[];
-    includeNodeValue?: boolean;
-    multiple?: boolean;
-    nodes: TreeNodeData[];
-    selectedValues?: TreeNodeValue[];
-}
-export declare function getTreeNodeEntities({ disabledValues, expandedValues, includeNodeValue, multiple, nodes, selectedValues, }: GetTreeNodeEntitiesProps): TreeNodeEntities;

package/Tree/getTreeNodeEntities.js

@@ -1,92 +0,0 @@
-import xor from 'lodash/xor';
-
-function getTreeNodeEntities({ disabledValues, expandedValues, includeNodeValue = false, multiple, nodes, selectedValues, }) {
-    const entities = new Map();
-    const selectedValueMap = (selectedValues === null || selectedValues === void 0 ? void 0 : selectedValues.length)
-        ? new Map(selectedValues.map((val) => [val, true]))
-        : undefined;
-    const expandedValueMap = (expandedValues === null || expandedValues === void 0 ? void 0 : expandedValues.length)
-        ? new Map(expandedValues.map((val) => [val, true]))
-        : undefined;
-    const disabledValueMap = (disabledValues === null || disabledValues === void 0 ? void 0 : disabledValues.length)
-        ? new Map(disabledValues.map((val) => [val, true]))
-        : undefined;
-    function getTreeEntity(node, parentDisabled) {
-        const { nodes: currentSiblings, value } = node;
-        const selected = selectedValueMap === null || selectedValueMap === void 0 ? void 0 : selectedValueMap.get(value);
-        const expanded = expandedValueMap === null || expandedValueMap === void 0 ? void 0 : expandedValueMap.get(value);
-        const disabled = disabledValueMap === null || disabledValueMap === void 0 ? void 0 : disabledValueMap.get(value);
-        const entity = {
-            node: {
-                ...node,
-                disabled: parentDisabled || disabled,
-                expanded,
-                selected,
-            },
-            values: [],
-        };
-        if (!(currentSiblings === null || currentSiblings === void 0 ? void 0 : currentSiblings.length)) {
-            entities.set(entity.node.value, entity);
-            entity.values.push(value);
-            return entity;
-        }
-        const { anyIndeterminate, directSiblings, disabledValues: siblingDisabledValues, selectedValues: siblingSelectedValues, siblingNodes, siblings: siblingEntities, values: siblingValues, } = currentSiblings.reduce((acc, sibling) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const siblingEntity = getTreeEntity(sibling, parentDisabled || disabled);
-            const currentAnyIndeterminate = siblingEntity.node.indeterminate || acc.anyIndeterminate;
-            return {
-                anyIndeterminate: currentAnyIndeterminate,
-                directSiblings: [...acc.directSiblings, siblingEntity.node.value],
-                disabledValues: siblingEntity.node.disabled
-                    ? [...acc.disabledValues, siblingEntity.node.value]
-                    : acc.disabledValues,
-                selectedValues: siblingEntity.node.selected
-                    ? [...acc.selectedValues, siblingEntity.node.value]
-                    : acc.selectedValues,
-                siblingNodes: [...acc.siblingNodes, siblingEntity.node],
-                siblings: [...acc.siblings, siblingEntity],
-                values: [...acc.values, ...siblingEntity.values],
-            };
-        }, {
-            anyIndeterminate: false,
-            directSiblings: [],
-            disabledValues: [],
-            selectedValues: [],
-            siblingNodes: [],
-            siblings: [],
-            values: [],
-        });
-        entity.node.nodes = siblingNodes;
-        entity.siblings = siblingEntities;
-        entity.values.push(...siblingValues);
-        if (includeNodeValue) {
-            entity.values.push(value);
-        }
-        const shouldDisabled = siblingDisabledValues.length &&
-            !xor(siblingDisabledValues, directSiblings).length;
-        if (!disabled && shouldDisabled) {
-            entity.node.disabled = true;
-        }
-        if ((anyIndeterminate && !disabled && !shouldDisabled) ||
-            (!multiple && siblingSelectedValues.length)) {
-            entity.node.selected = false;
-            entity.node.indeterminate = true;
-            entities.set(entity.node.value, entity);
-            return entity;
-        }
-        const allDirectSiblingChecked = !!(siblingSelectedValues.length &&
-            !xor(siblingSelectedValues, directSiblings).length);
-        entity.node.selected = allDirectSiblingChecked;
-        entity.node.indeterminate = allDirectSiblingChecked
-            ? false
-            : !!siblingSelectedValues.length;
-        entities.set(entity.node.value, entity);
-        return entity;
-    }
-    nodes.forEach((node) => {
-        getTreeEntity(node, disabledValueMap === null || disabledValueMap === void 0 ? void 0 : disabledValueMap.get(node.value));
-    });
-    return entities;
-}
-
-export { getTreeNodeEntities };