primereact 8.7.3 → 9.0.0-rc.1

package/treeselect/treeselect.d.ts

@@ -1,130 +1,379 @@
+/**
+ *
+ * TreeSelect is a form component to choose from hierarchical data.
+ *
+ * [Live Demo](https://www.primefaces.org/primereact/treeselect/)
+ *
+ * @module treeselect
+ *
+ */
 import * as React from 'react';
 import { CSSTransitionProps } from '../csstransition';
 import TreeNode from '../treenode';
+import { FormEvent } from '../ts-helpers';
 
-type TreeSelectSelectionModeType = 'single' | 'multiple' | 'checkbox';
-
-type TreeSelectSelectionKeys = string | TreeSelectSelectionKeysType | TreeSelectSelectionKeysType[] | undefined | null;
-
-type TreeSelectDisplayType = 'comma' | 'chip';
-
-type TreeSelectFilterModeType = 'lenient' | 'strict';
-
-type TreeSelectValueTemplateType = React.ReactNode | ((selectedNodes: TreeNode | TreeNode[], props: TreeSelectProps) => React.ReactNode);
-
-type TreeSelectFilterTemplateType = React.ReactNode | ((options: TreeSelectFilterOptions) => React.ReactNode);
-
-type TreeSelectPanelHeaderTemplateType = React.ReactNode | ((options: TreeSelectPanelHeaderTemplateOptions) => React.ReactNode);
-
-type TreeSelectPanelFooterTemplateType = React.ReactNode | ((props: TreeSelectProps) => React.ReactNode);
-
-type TreeSelectAppendToType = 'self' | HTMLElement | undefined | null;
-
+/**
+ * Custom panel header template options.
+ * @group Misc
+ */
 interface TreeSelectPanelHeaderTemplateOptions {
+    /**
+     * Style class of the panel.
+     */
     className: string;
+    /**
+     * The JSX element that represents the filter of the panel.
+     */
     filterElement: JSX.Element;
+    /**
+     * The JSX element that represents the close of the panel.
+     */
     closeElement: JSX.Element;
+    /**
+     * Style class of the panel close element.
+     */
     closeElementClassName: string;
+    /**
+     * Style class of the panel close icon.
+     */
     closeIconClassName: string;
+    /**
+     * Callback to invoke when the close button is clicked.
+     */
     onCloseClick(): void;
+    /**
+     * The JSX element that represents the panel.
+     */
     element: JSX.Element;
+    /**
+     * The props of the TreeSelect component.
+     */
     props: TreeSelectProps;
 }
 
-interface TreeSelectChangeTargetOptions {
-    name: string;
-    id: string;
-    value: TreeSelectSelectionKeys;
-}
-
-interface TreeSelectChangeParams {
-    originalEvent: React.SyntheticEvent;
-    value: TreeSelectSelectionKeys;
-    stopPropagation(): void;
-    preventDefault(): void;
-    target: TreeSelectChangeTargetOptions;
-}
-
-type TreeSelectSelectionKeyType = boolean | TreeSelectCheckboxSelectionKeyType;
+/**
+ * Custom change event.
+ * @see {@link TreeSelectProps.onChange}
+ * @extends {FormEvent}
+ * @event
+ */
+interface TreeSelectChangeEvent extends FormEvent<string | TreeSelectSelectionKeysType | TreeSelectSelectionKeysType[]> {}
 
+/**
+ * Custom treeselect selection keys type
+ * @group Misc
+ */
 interface TreeSelectSelectionKeysType {
-    [key: string]: TreeSelectSelectionKeyType;
+    /**
+     * Extra options.
+     */
+    [key: string]: boolean | TreeSelectCheckboxSelectionKeyType;
 }
 
+/**
+ * Custom checkbox selection key type
+ * @group Misc
+ */
 interface TreeSelectCheckboxSelectionKeyType {
+    /**
+     * Whether the checkbox is checked or not.
+     */
     checked?: boolean;
+    /**
+     * Whether the checkbox is partially checked or not.
+     */
     partialChecked?: boolean;
 }
 
-interface TreeSelectEventNodeParams {
+/**
+ * Custom change event.
+ * @see {@link TreeSelectProps.onNodeCollapse},{@link TreeSelectProps.onNodeExpand},{@link TreeSelectProps.onNodeSelect},{@link TreeSelectProps.onNodeUnselect}
+ * @event
+ */
+interface TreeSelectEventNodeEvent {
+    /**
+     * Browser event
+     */
     originalEvent: React.SyntheticEvent;
+    /**
+     * Unselected node instance.
+     */
     node: TreeNode;
 }
 
+/**
+ * Custom expanded keys type.
+ * @group Misc
+ */
 interface TreeSelectExpandedKeysType {
+    /**
+     * Extra options.
+     */
     [key: string]: boolean;
 }
 
-interface TreeSelectExpandedParams {
+/**
+ * Custom toggle event.
+ * @see {@link TreeSelectProps.onToggle}
+ * @event
+ */
+interface TreeSelectExpandedEvent {
+    /**
+     * Browser event
+     */
     originalEvent: React.SyntheticEvent;
+    /**
+     * Toggled node instance
+     */
     value: TreeSelectExpandedKeysType;
 }
 
-interface TreeSelectFilterValueChangeParams {
+/**
+ * Custom filter change event.
+ * @see {@link TreeSelectProps.onFilterValueChange}
+ * @event
+ */
+interface TreeSelectFilterValueChangeEvent {
+    /**
+     * Browser event
+     */
     originalEvent: React.FormEvent<HTMLInputElement>;
+    /**
+     * The filtered value
+     */
     value: string;
 }
 
+/**
+ * Custom filter options.
+ * @group Misc
+ */
 interface TreeSelectFilterOptions {
+    /**
+     * Used to filter options
+     * @param {KeyboardEvent} event - Browser event.
+     */
     filter?: (event?: KeyboardEvent) => void;
+    /**
+     * Used to reset the filtered options
+     */
     reset?: () => void;
 }
 
+/**
+ * Defines valid properties in TreeSelect component. In addition to these, all properties of HTMLDivElement can be used in this component.
+ * @group Properties
+ */
 export interface TreeSelectProps extends Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'onChange' | 'value' | 'ref'> {
-    appendTo?: TreeSelectAppendToType;
-    ariaLabel?: string;
-    ariaLabelledBy?: string;
-    children?: React.ReactNode;
-    disabled?: boolean;
-    display?: TreeSelectDisplayType;
-    dropdownIcon?: string;
-    emptyMessage?: string;
-    expandedKeys?: TreeSelectExpandedKeysType;
-    filter?: boolean;
-    filterBy?: string;
-    filterInputAutoFocus?: boolean;
-    filterLocale?: string;
-    filterMode?: TreeSelectFilterModeType;
-    filterPlaceholder?: string;
-    filterTemplate?: TreeSelectFilterTemplateType;
-    filterValue?: string;
-    inputId?: string;
-    inputRef?: React.Ref<HTMLInputElement>;
-    metaKeySelection?: boolean;
-    name?: string;
-    options?: TreeNode[];
-    panelClassName?: string;
-    panelFooterTemplate?: TreeSelectPanelFooterTemplateType;
-    panelHeaderTemplate?: TreeSelectPanelHeaderTemplateType;
-    panelStyle?: React.CSSProperties;
-    placeholder?: string;
-    resetFilterOnHide?: boolean;
-    scrollHeight?: string;
-    selectionMode?: TreeSelectSelectionModeType;
-    transitionOptions?: CSSTransitionProps;
-    value?: TreeSelectSelectionKeys;
-    valueTemplate?: TreeSelectValueTemplateType;
-    onChange?(e: TreeSelectChangeParams): void;
-    onFilterValueChange?(e: TreeSelectFilterValueChangeParams): void;
+    /**
+     * DOM element instance where the overlay panel should be mounted. Valid values are any DOM Element and 'self'. The self value is used to render a component where it is located.
+     * @defaultValue document.body
+     */
+    appendTo?: 'self' | HTMLElement | undefined | null;
+    /**
+     * Used to define a string that labels the component.
+     */
+    ariaLabel?: string | undefined;
+    /**
+     * Establishes relationships between the component and label(s) where its value should be one or more element IDs.
+     */
+    ariaLabelledBy?: string | undefined;
+    /**
+     * Used to get the child elements of the component.
+     * @readonly
+     */
+    children?: React.ReactNode | undefined;
+    /**
+     * When present, it specifies that the component should be disabled.
+     * @defaultValue false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Defines how the selected items are displayed, valid values are "comma" and "chip".
+     * @defaultValue comma
+     */
+    display?: 'comma' | 'chip' | undefined;
+    /**
+     * Icon class of the dropdown icon.
+     * @defaultValue pi pi-chevron-down
+     */
+    dropdownIcon?: string | undefined;
+    /**
+     * Text to display when there is no data.
+     */
+    emptyMessage?: string | undefined;
+    /**
+     * An array of keys to represent the state of the treeselect expansion state in controlled mode.
+     */
+    expandedKeys?: TreeSelectExpandedKeysType | undefined;
+    /**
+     * When specified, displays an input field to filter the items.
+     * @defaultValue false
+     */
+    filter?: boolean | undefined;
+    /**
+     * When filtering is enabled, filterBy decides which field or fields (comma separated) to search against.
+     * @defaultValue label
+     */
+    filterBy?: string | undefined;
+    /**
+     * When the panel is opened, it specifies that the filter input should focus automatically.
+     * @defaultValue true
+     */
+    filterInputAutoFocus?: boolean | undefined;
+    /**
+     * Locale to use in filtering. The default locale is the host environment's current locale.
+     * @defaultValue undefined
+     */
+    filterLocale?: string | undefined;
+    /**
+     * Mode for filtering valid values are "lenient" and "strict". Default is lenient.
+     * @defaultValue lenient
+     */
+    filterMode?: 'lenient' | 'strict' | undefined;
+    /**
+     * Placeholder text to show when filter input is empty.
+     */
+    filterPlaceholder?: string | undefined;
+    /**
+     * The template for filter element.
+     */
+    filterTemplate?: React.ReactNode | ((options: TreeSelectFilterOptions) => React.ReactNode);
+    /**
+     * When filtering is enabled, the value of input field.
+     */
+    filterValue?: string | undefined;
+    /**
+     * Identifier of the input element.
+     */
+    inputId?: string | undefined;
+    /**
+     * Reference of the input element.
+     */
+    inputRef?: React.Ref<HTMLInputElement> | undefined;
+    /**
+     * Defines how multiple items can be selected, when true metaKey needs to be pressed to select or unselect an item and when set to false selection of each item can be toggled individually. On touch enabled devices, metaKeySelection is turned off automatically.
+     * @defaultValue true
+     */
+    metaKeySelection?: boolean | undefined;
+    /**
+     * Name of the input element.
+     */
+    name?: string | undefined;
+    /**
+     * An array of options to display.
+     */
+    options?: TreeNode[] | undefined;
+    /**
+     * Style class of the overlay panel element.
+     */
+    panelClassName?: string | undefined;
+    /**
+     * The template of footer.
+     */
+    panelFooterTemplate?: React.ReactNode | ((props: TreeSelectProps) => React.ReactNode);
+    /**
+     * The template of header.
+     */
+    panelHeaderTemplate?: React.ReactNode | ((options: TreeSelectPanelHeaderTemplateOptions) => React.ReactNode);
+    /**
+     * Inline style of the overlay panel element.
+     */
+    panelStyle?: React.CSSProperties | undefined;
+    /**
+     * Hint text for the input field.
+     */
+    placeholder?: string | undefined;
+    /**
+     * Clears the filter value when hiding the dropdown.
+     * @defaultValue false
+     */
+    resetFilterOnHide?: boolean | undefined;
+    /**
+     * Maximum height of the options panel.
+     * @defaultValue 400px
+     */
+    scrollHeight?: string | undefined;
+    /**
+     * Defines the selection mode, valid values "single", "multiple", and "checkbox".
+     */
+    selectionMode?: 'single' | 'multiple' | 'checkbox' | undefined;
+    /**
+     * The properties of CSSTransition can be customized, except for "nodeRef" and "in" properties.
+     */
+    transitionOptions?: CSSTransitionProps | undefined;
+    /**
+     * A single or an object of keys to control the selection state.
+     */
+    value?: string | TreeSelectSelectionKeysType | TreeSelectSelectionKeysType[] | undefined | null;
+    /**
+     * The template of selected values.
+     */
+    valueTemplate?: React.ReactNode | ((selectedNodes: TreeNode | TreeNode[], props: TreeSelectProps) => React.ReactNode);
+    /**
+     * Callback to invoke when selection changes.
+     * @param {TreeSelectChangeEvent} event - Custom change event.
+     */
+    onChange?(event: TreeSelectChangeEvent): void;
+    /**
+     * Callback to invoke when filter value changes.
+     * @param {TreeSelectFilterValueChangeEvent} event - Custom filter change event.
+     */
+    onFilterValueChange?(event: TreeSelectFilterValueChangeEvent): void;
+    /**
+     * Used to hide the overlay.
+     */
     onHide?(): void;
-    onNodeCollapse?(e: TreeSelectEventNodeParams): void;
-    onNodeExpand?(e: TreeSelectEventNodeParams): void;
-    onNodeSelect?(e: TreeSelectEventNodeParams): void;
-    onNodeUnselect?(e: TreeSelectEventNodeParams): void;
+    /**
+     * Callback to invoke when a node is collapsed.
+     * @param {TreeSelectEventNodeEvent} event - Custom change event.
+     */
+    onNodeCollapse?(event: TreeSelectEventNodeEvent): void;
+    /**
+     * Callback to invoke when a node is expanded.
+     * @param {TreeSelectEventNodeEvent} event - Custom change event.
+     */
+    onNodeExpand?(event: TreeSelectEventNodeEvent): void;
+    /**
+     * Callback to invoke when a node is selected.
+     * @param {TreeSelectEventNodeEvent} event - Custom change event.
+     */
+    onNodeSelect?(event: TreeSelectEventNodeEvent): void;
+    /**
+     * Callback to invoke when a node is unselected.
+     * @param {TreeSelectEventNodeEvent} event - Custom change event.
+     */
+    onNodeUnselect?(event: TreeSelectEventNodeEvent): void;
+    /**
+     * Used to show the overlay.
+     */
     onShow?(): void;
-    onToggle?(e: TreeSelectExpandedParams): void;
+    /**
+     * Callback to invoke when a node is toggled.
+     * @param {TreeSelectExpandedEvent} event - Custom toggle event.
+     */
+    onToggle?(event: TreeSelectExpandedEvent): void;
 }
 
+/**
+ * **PrimeReact - TreeSelect**
+ *
+ * _TreeSelect is a form component to choose from hierarchical data._
+ *
+ * [Live Demo](https://www.primefaces.org/primereact/treeselect/)
+ * --- ---
+ * ![PrimeReact](https://primefaces.org/cdn/primereact/images/logo-100.png)
+ *
+ * @group Component
+ */
 export declare class TreeSelect extends React.Component<TreeSelectProps, any> {
+    /**
+     * Used to focus the component.
+     */
+    public focus(): void;
+    /**
+     * Used to get container element.
+     * @return {HTMLDivElement} Container element
+     */
     public getElement(): HTMLDivElement;
 }

package/treeselect/treeselect.esm.js

@@ -4,7 +4,7 @@ import { useOverlayListener, useMountEffect, useUpdateEffect, useUnmountEffect }
 import { OverlayService } from 'primereact/overlayservice';
 import { Ripple } from 'primereact/ripple';
 import { Tree } from 'primereact/tree';
-import { classNames, ObjectUtils, ZIndexUtils, DomHandler } from 'primereact/utils';
+import { ObjectUtils, classNames, DomHandler, ZIndexUtils } from 'primereact/utils';
 import { CSSTransition } from 'primereact/csstransition';
 import { Portal } from 'primereact/portal';
 
@@ -82,9 +82,7 @@ function _iterableToArrayLimit(arr, i) {
       if (_x = (_i = _i.call(arr)).next, 0 === i) {
         if (Object(_i) !== _i) return;
         _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) {
-        ;
-      }
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
     } catch (err) {
       _d = !0, _e = err;
     } finally {
@@ -100,9 +98,7 @@ function _iterableToArrayLimit(arr, i) {
 
 function _arrayLikeToArray$1(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
-  }
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
   return arr2;
 }
 
@@ -123,12 +119,71 @@ function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
 }
 
+var TreeSelectBase = {
+  defaultProps: {
+    __TYPE: 'TreeSelect',
+    appendTo: null,
+    ariaLabel: null,
+    ariaLabelledBy: null,
+    className: null,
+    disabled: false,
+    display: 'comma',
+    dropdownIcon: 'pi pi-chevron-down',
+    emptyMessage: null,
+    expandedKeys: null,
+    filter: false,
+    filterBy: 'label',
+    filterInputAutoFocus: true,
+    filterLocale: undefined,
+    filterMode: 'lenient',
+    filterPlaceholder: null,
+    filterTemplate: null,
+    filterValue: null,
+    inputId: null,
+    inputRef: null,
+    metaKeySelection: true,
+    name: null,
+    onChange: null,
+    onFilterValueChange: null,
+    onHide: null,
+    onNodeCollapse: null,
+    onNodeExpand: null,
+    onNodeSelect: null,
+    onNodeUnselect: null,
+    onShow: null,
+    options: null,
+    panelClassName: null,
+    panelFooterTemplate: null,
+    panelHeaderTemplate: null,
+    panelStyle: null,
+    placeholder: null,
+    resetFilterOnHide: false,
+    scrollHeight: '400px',
+    selectionMode: 'single',
+    style: null,
+    tabIndex: null,
+    transitionOptions: null,
+    value: null,
+    valueTemplate: null,
+    children: undefined
+  },
+  getProps: function getProps(props) {
+    return ObjectUtils.getMergedProps(props, TreeSelectBase.defaultProps);
+  },
+  getOtherProps: function getOtherProps(props) {
+    return ObjectUtils.getDiffProps(props, TreeSelectBase.defaultProps);
+  }
+};
+
 var TreeSelectPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var createElement = function createElement() {
     var wrapperStyle = {
       maxHeight: props.scrollHeight || 'auto'
     };
-    var className = classNames('p-treeselect-panel p-component', props.panelClassName);
+    var className = classNames('p-treeselect-panel p-component', props.panelClassName, {
+      'p-input-filled': PrimeReact.inputStyle === 'filled',
+      'p-ripple-disabled': PrimeReact.ripple === false
+    });
     return /*#__PURE__*/React.createElement(CSSTransition, {
       nodeRef: ref,
       classNames: "p-connected-overlay",
@@ -166,8 +221,9 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-var TreeSelect = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(function (props, ref) {
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var TreeSelect = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(function (inProps, ref) {
+  var props = TreeSelectBase.getProps(inProps);
   var _React$useState = React.useState(false),
     _React$useState2 = _slicedToArray(_React$useState, 2),
     focusedState = _React$useState2[0],
@@ -474,6 +530,9 @@ var TreeSelect = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(function
   React.useImperativeHandle(ref, function () {
     return {
       props: props,
+      focus: function focus() {
+        return DomHandler.focus(focusInputRef.current);
+      },
       getElement: function getElement() {
         return elementRef.current;
       }
@@ -657,7 +716,7 @@ var TreeSelect = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(function
     return ObjectUtils.getJSXElement(props.panelFooterTemplate, props);
   };
   var selectedNodes = getSelectedNodes();
-  var otherProps = ObjectUtils.findDiffKeys(props, TreeSelect.defaultProps);
+  var otherProps = TreeSelectBase.getOtherProps(props);
   var ariaProps = ObjectUtils.reduceKeys(otherProps, DomHandler.ARIA_PROPS);
   var className = classNames('p-treeselect p-component p-inputwrapper', {
     'p-treeselect-chip': props.display === 'chip',
@@ -696,51 +755,5 @@ var TreeSelect = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef(function
   }, content));
 }));
 TreeSelect.displayName = 'TreeSelect';
-TreeSelect.defaultProps = {
-  __TYPE: 'TreeSelect',
-  appendTo: null,
-  ariaLabel: null,
-  ariaLabelledBy: null,
-  className: null,
-  disabled: false,
-  display: 'comma',
-  dropdownIcon: 'pi pi-chevron-down',
-  emptyMessage: null,
-  expandedKeys: null,
-  filter: false,
-  filterBy: 'label',
-  filterInputAutoFocus: true,
-  filterLocale: undefined,
-  filterMode: 'lenient',
-  filterPlaceholder: null,
-  filterTemplate: null,
-  filterValue: null,
-  inputId: null,
-  inputRef: null,
-  metaKeySelection: true,
-  name: null,
-  onChange: null,
-  onFilterValueChange: null,
-  onHide: null,
-  onNodeCollapse: null,
-  onNodeExpand: null,
-  onNodeSelect: null,
-  onNodeUnselect: null,
-  onShow: null,
-  options: null,
-  panelClassName: null,
-  panelFooterTemplate: null,
-  panelHeaderTemplate: null,
-  panelStyle: null,
-  placeholder: null,
-  resetFilterOnHide: false,
-  scrollHeight: '400px',
-  selectionMode: 'single',
-  style: null,
-  tabIndex: null,
-  transitionOptions: null,
-  value: null,
-  valueTemplate: null
-};
 
 export { TreeSelect };