@synerise/ds-factors 1.11.11 → 1.11.13

package/dist/FactorValue/Parameter/Parameter.types.js

@@ -1 +1 @@
-export {};
+

package/dist/FactorValue/Parameter/ParameterDropdown.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type ParameterDropdownProps } from '../../Factors.types';
+import { default as React } from 'react';
+import { ParameterDropdownProps } from '../../Factors.types';
 declare const ParameterDropdown: ({ setSelected, texts, groups, items, recentItems, setDropdownVisible, loading, onFetchData, hasMoreItems, outerHeight, value, renderEmptyGroups, maxSearchResultsInGroup, }: ParameterDropdownProps) => React.JSX.Element;
 export default ParameterDropdown;

package/dist/FactorValue/Parameter/ParameterDropdown.js

@@ -1,238 +1,217 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { v4 as uuid } from 'uuid';
-import { useTheme } from '@synerise/ds-core';
-import Divider from '@synerise/ds-divider';
-import Dropdown from '@synerise/ds-dropdown';
-import Icon, { ArrowRightCircleM, SearchM } from '@synerise/ds-icon';
-import { ListContextProvider, itemSizes } from '@synerise/ds-list-item';
-import Result from '@synerise/ds-result';
-import Scrollbar from '@synerise/ds-scrollbar';
-import Tabs from '@synerise/ds-tabs';
-import { focusWithArrowKeys, getClosest, getGroupName, useOnClickOutside, useSearchResults } from '@synerise/ds-utils';
-import { DROPDOWN_HEIGHT, ITEM_SIZE, LIST_STYLE, NO_GROUP_NAME, SEARCH_HEGIHT, SUBGROUP_HEADER_HEIGHT, TABS_HEIGHT } from './Parameter.constants';
-import * as S from './Parameter.style';
-import ParameterDropdownItem from './ParameterDropdownItem';
-import { useGroups } from './useGroups';
-import { groupItems, isDivider, isListTitle } from './utils';
-var ParameterDropdown = function ParameterDropdown(_ref) {
-  var setSelected = _ref.setSelected,
-    texts = _ref.texts,
-    groups = _ref.groups,
-    items = _ref.items,
-    recentItems = _ref.recentItems,
-    setDropdownVisible = _ref.setDropdownVisible,
-    loading = _ref.loading,
-    onFetchData = _ref.onFetchData,
-    hasMoreItems = _ref.hasMoreItems,
-    _ref$outerHeight = _ref.outerHeight,
-    outerHeight = _ref$outerHeight === void 0 ? DROPDOWN_HEIGHT : _ref$outerHeight,
-    value = _ref.value,
-    _ref$renderEmptyGroup = _ref.renderEmptyGroups,
-    renderEmptyGroups = _ref$renderEmptyGroup === void 0 ? false : _ref$renderEmptyGroup,
-    _ref$maxSearchResults = _ref.maxSearchResultsInGroup,
-    maxSearchResultsInGroup = _ref$maxSearchResults === void 0 ? 4 : _ref$maxSearchResults;
-  var listRef = useRef(null);
-  var overlayRef = useRef(null);
-  var scrollBarRef = useRef(null);
-  var theme = useTheme();
-  var _useGroups = useGroups(items, groups, renderEmptyGroups),
-    visibleGroups = _useGroups.visibleGroups,
-    tabs = _useGroups.tabs,
-    defaultTab = _useGroups.defaultTab;
-  var _useState = useState(''),
-    searchQuery = _useState[0],
-    setSearchQuery = _useState[1];
-  var _useState2 = useState(defaultTab),
-    activeTab = _useState2[0],
-    setActiveTab = _useState2[1];
-  var _useState3 = useState(undefined),
-    activeGroup = _useState3[0],
-    setActiveGroup = _useState3[1];
-  var _useState4 = useState(true),
-    searchInputCanBeFocused = _useState4[0],
-    setSearchInputFocus = _useState4[1];
-  var classNames = useMemo(function () {
-    return "ds-parameter-item ds-parameter-item-" + uuid();
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useRef, useState, useMemo, useCallback, useEffect } from "react";
+import { v4 } from "uuid";
+import { useTheme } from "@synerise/ds-core";
+import Divider from "@synerise/ds-divider";
+import Dropdown from "@synerise/ds-dropdown";
+import Icon, { ArrowRightCircleM, SearchM } from "@synerise/ds-icon";
+import { ListContextProvider, itemSizes } from "@synerise/ds-list-item";
+import Result from "@synerise/ds-result";
+import Scrollbar from "@synerise/ds-scrollbar";
+import Tabs from "@synerise/ds-tabs";
+import { useOnClickOutside, getClosest, getGroupName, useSearchResults, focusWithArrowKeys } from "@synerise/ds-utils";
+import { NO_GROUP_NAME, DROPDOWN_HEIGHT, LIST_STYLE, SEARCH_HEGIHT, TABS_HEIGHT, SUBGROUP_HEADER_HEIGHT, ITEM_SIZE } from "./Parameter.constants.js";
+import { ShowMoreItem, TabsWrapper, Skeleton, ItemsList, StyledList, Title } from "./Parameter.style.js";
+import ParameterDropdownItem from "./ParameterDropdownItem.js";
+import { useGroups } from "./useGroups.js";
+import { groupItems, isDivider, isListTitle } from "./utils.js";
+const ParameterDropdown = ({
+  setSelected,
+  texts,
+  groups,
+  items,
+  recentItems,
+  setDropdownVisible,
+  loading,
+  onFetchData,
+  hasMoreItems,
+  outerHeight = DROPDOWN_HEIGHT,
+  value,
+  renderEmptyGroups = false,
+  maxSearchResultsInGroup = 4
+}) => {
+  const listRef = useRef(null);
+  const overlayRef = useRef(null);
+  const scrollBarRef = useRef(null);
+  const theme = useTheme();
+  const {
+    visibleGroups,
+    tabs,
+    defaultTab
+  } = useGroups(items, groups, renderEmptyGroups);
+  const [searchQuery, setSearchQuery] = useState("");
+  const [activeTab, setActiveTab] = useState(defaultTab);
+  const [activeGroup, setActiveGroup] = useState(void 0);
+  const [searchInputCanBeFocused, setSearchInputFocus] = useState(true);
+  const classNames = useMemo(() => {
+    return `ds-parameter-item ds-parameter-item-${v4()}`;
   }, []);
-  useOnClickOutside(overlayRef, function (event) {
-    if (getClosest(event.target, '.ds-info-card') === null) {
+  useOnClickOutside(overlayRef, (event) => {
+    if (getClosest(event.target, ".ds-info-card") === null) {
       setDropdownVisible(false);
     }
   });
-  var currentTabItems = useMemo(function () {
-    return visibleGroups == null ? void 0 : visibleGroups.find(function (_group, index) {
+  const currentTabItems = useMemo(() => {
+    return visibleGroups?.find((_group, index) => {
       return activeTab === index;
     });
   }, [visibleGroups, activeTab]);
-  var resetList = React.useCallback(function () {
+  const resetList = React.useCallback(() => {
     if (listRef.current) {
       listRef.current.resetAfterIndex(0, false);
     }
   }, [listRef]);
-  var clearSearch = useCallback(function () {
-    setSearchQuery('');
+  const clearSearch = useCallback(() => {
+    setSearchQuery("");
     resetList();
   }, [setSearchQuery, resetList]);
-  var handleOnSetGroup = useCallback(function (item) {
+  const handleOnSetGroup = useCallback((item) => {
     setActiveGroup(item);
   }, []);
-  var hideDropdown = useCallback(function () {
+  const hideDropdown = useCallback(() => {
     setDropdownVisible(false);
     resetList();
   }, [setDropdownVisible, resetList]);
-  var groupByGroupName = useCallback(function (dropdownItems, maxItemsInGroup) {
-    var itemsNumber = dropdownItems == null ? void 0 : dropdownItems.length;
-    var groupedItems = {};
-    for (var i = 0; i < itemsNumber; i += 1) {
-      var item = dropdownItems[i];
-      var groupName = item.groupName || NO_GROUP_NAME;
-      var group = groupedItems[groupName] || [];
+  const groupByGroupName = useCallback((dropdownItems, maxItemsInGroup) => {
+    const itemsNumber = dropdownItems?.length;
+    const groupedItems = {};
+    for (let i = 0; i < itemsNumber; i += 1) {
+      const item = dropdownItems[i];
+      const groupName = item.groupName || NO_GROUP_NAME;
+      const group = groupedItems[groupName] || [];
       group.push(item);
       groupedItems[groupName] = group;
     }
-    var resultItems = [];
-    Object.keys(groupedItems).forEach(function (key) {
+    const resultItems = [];
+    Object.keys(groupedItems).forEach((key) => {
       if (key !== NO_GROUP_NAME && !activeGroup) {
         resultItems.push({
-          type: 'title',
+          type: "title",
           title: key
         });
       }
-      var maxGroupedItems = maxItemsInGroup ? groupedItems[key].slice(0, maxItemsInGroup) : groupedItems[key];
-      maxGroupedItems.forEach(function (item) {
-        var resultItem = !item.groupId ? {
+      const maxGroupedItems = maxItemsInGroup ? groupedItems[key].slice(0, maxItemsInGroup) : groupedItems[key];
+      maxGroupedItems.forEach((item) => {
+        const resultItem = !item.groupId ? {
           className: classNames,
-          item: item,
-          searchQuery: searchQuery,
+          item,
+          searchQuery,
           select: handleOnSetGroup
         } : {
           className: classNames,
-          item: item,
-          searchQuery: searchQuery,
-          clearSearch: clearSearch,
-          hideDropdown: hideDropdown,
+          item,
+          searchQuery,
+          clearSearch,
+          hideDropdown,
           select: setSelected,
-          selected: value && item.id === (value == null ? void 0 : value.id)
+          selected: value && item.id === value?.id
         };
         resultItems.push(resultItem);
       });
       if (maxItemsInGroup && groupedItems[key].length > maxItemsInGroup) {
-        var anyItem = maxGroupedItems[0];
+        const anyItem = maxGroupedItems[0];
         resultItems.push({
           className: classNames,
           select: handleOnSetGroup,
-          searchQuery: searchQuery,
-          label: /*#__PURE__*/React.createElement(S.ShowMoreItem, null, texts.parameter.showMore),
+          searchQuery,
+          label: /* @__PURE__ */ jsx(ShowMoreItem, { children: texts.parameter.showMore }),
           item: {
             isGroup: true,
             id: anyItem.groupId,
-            name: getGroupName(anyItem.groupId, groups || []) || '',
-            icon: /*#__PURE__*/React.createElement(ArrowRightCircleM, null)
+            name: getGroupName(anyItem.groupId, groups || []) || "",
+            icon: /* @__PURE__ */ jsx(ArrowRightCircleM, {})
           }
         });
       }
     });
     return resultItems;
   }, [activeGroup, classNames, searchQuery, handleOnSetGroup, clearSearch, hideDropdown, setSelected, value, texts.parameter.showMore, groups]);
-  var _useSearchResults = useSearchResults(items || [], groups || [], activeTab, groupByGroupName, activeGroup, searchQuery, maxSearchResultsInGroup),
-    searchResults = _useSearchResults.searchResults;
-  var mapItemToDropdownItem = React.useCallback(function (item) {
+  const {
+    searchResults
+  } = useSearchResults(items || [], groups || [], activeTab, groupByGroupName, activeGroup, searchQuery, maxSearchResultsInGroup);
+  const mapItemToDropdownItem = React.useCallback((item) => {
     return {
       className: classNames,
-      item: item,
-      searchQuery: searchQuery,
-      hideDropdown: hideDropdown,
+      item,
+      searchQuery,
+      hideDropdown,
       select: setSelected
     };
   }, [classNames, searchQuery, hideDropdown, setSelected]);
-  var currentItems = useMemo(function () {
+  const currentItems = useMemo(() => {
     if (searchQuery) {
       return searchResults;
     }
-    var hasSubgroups = Boolean(currentTabItems == null ? void 0 : currentTabItems.subGroups);
+    const hasSubgroups = Boolean(currentTabItems?.subGroups);
     if (hasSubgroups && !activeGroup) {
-      var groupedItems = (items || []).filter(function (item) {
-        return item.groupId === (currentTabItems == null ? void 0 : currentTabItems.id);
-      }).map(mapItemToDropdownItem);
-      var subGroups = ((currentTabItems == null ? void 0 : currentTabItems.subGroups) || []).map(function (subGroup) {
+      const groupedItems = (items || []).filter((item) => item.groupId === currentTabItems?.id).map(mapItemToDropdownItem);
+      const subGroups = (currentTabItems?.subGroups || []).map((subGroup) => {
         return {
           className: classNames,
           item: subGroup,
-          searchQuery: searchQuery,
-          select: function select(group) {
+          searchQuery,
+          select: (group) => {
             setActiveGroup(group);
             resetList();
           }
         };
       });
-      return groupItems([].concat(groupedItems, subGroups), activeGroup);
+      return groupItems([...groupedItems, ...subGroups], activeGroup);
     }
     if (activeGroup) {
-      return groupItems((items || []).filter(function (item) {
-        return item.groupId === activeGroup.id;
-      }).map(mapItemToDropdownItem), activeGroup);
+      return groupItems((items || []).filter((item) => item.groupId === activeGroup.id).map(mapItemToDropdownItem), activeGroup);
     }
     if (activeTab && visibleGroups && visibleGroups[activeTab]) {
-      return items == null ? void 0 : items.filter(function (item) {
-        return item.groupId === visibleGroups[activeTab].id;
-      }).map(function (item) {
+      return items?.filter((item) => item.groupId === visibleGroups[activeTab].id).map((item) => {
         return {
           className: classNames,
-          item: item,
-          searchQuery: searchQuery,
-          hideDropdown: hideDropdown,
+          item,
+          searchQuery,
+          hideDropdown,
           select: setSelected
         };
       });
     }
     if (activeTab && groups && groups[activeTab]) {
-      return groupItems((items || []).filter(function (item) {
-        return item.groupId === groups[activeTab].id;
-      }).map(mapItemToDropdownItem), activeGroup);
+      return groupItems((items || []).filter((item) => item.groupId === groups[activeTab].id).map(mapItemToDropdownItem), activeGroup);
     }
     if ((recentItems || []).length > 0) {
-      var recentItemsWithGroup = (recentItems || []).map(function (item) {
-        return _extends({}, item, {
-          groupName: texts.parameter.recentItemsGroupName
-        });
-      });
-      var itemsWithAllGroup = (items || []).map(function (item) {
-        return _extends({}, item, {
-          groupName: texts.parameter.allItemsGroupName
-        });
-      });
-      var result = groupByGroupName(recentItemsWithGroup.concat(itemsWithAllGroup));
+      const recentItemsWithGroup = (recentItems || []).map((item) => ({
+        ...item,
+        groupName: texts.parameter.recentItemsGroupName
+      }));
+      const itemsWithAllGroup = (items || []).map((item) => ({
+        ...item,
+        groupName: texts.parameter.allItemsGroupName
+      }));
+      const result = groupByGroupName(recentItemsWithGroup.concat(itemsWithAllGroup));
       return result;
     }
-    return items == null ? void 0 : items.map(function (item) {
+    return items?.map((item) => {
       return {
         className: classNames,
-        item: item,
-        searchQuery: searchQuery,
-        hideDropdown: hideDropdown,
+        item,
+        searchQuery,
+        hideDropdown,
         select: setSelected
       };
     });
   }, [searchQuery, currentTabItems, activeGroup, visibleGroups, items, searchResults, classNames, hideDropdown, setSelected, activeTab, groupByGroupName, recentItems, groups, mapItemToDropdownItem, resetList, texts.parameter.allItemsGroupName, texts.parameter.recentItemsGroupName]);
-  var handleSearch = useCallback(function (newSearchQuery) {
+  const handleSearch = useCallback((newSearchQuery) => {
     setSearchQuery(newSearchQuery);
   }, [setSearchQuery]);
-  var getNoResultContainer = useMemo(function () {
-    return /*#__PURE__*/React.createElement(Result, {
-      noSearchResults: true,
-      type: "no-results",
-      description: texts.parameter.noResults
-    });
-  }, [texts]);
-  var handleScroll = function handleScroll(_ref2) {
-    var currentTarget = _ref2.currentTarget;
-    var scrollTop = currentTarget.scrollTop;
+  const getNoResultContainer = useMemo(() => /* @__PURE__ */ jsx(Result, { noSearchResults: true, type: "no-results", description: texts.parameter.noResults }), [texts]);
+  const handleScroll = ({
+    currentTarget
+  }) => {
+    const {
+      scrollTop
+    } = currentTarget;
     if (listRef.current) {
       listRef.current.scrollTo(scrollTop);
     }
   };
-  useEffect(function () {
+  useEffect(() => {
     if (scrollBarRef.current && listRef.current) {
       scrollBarRef.current.scrollTo({
         top: 0
@@ -240,96 +219,46 @@ var ParameterDropdown = function ParameterDropdown(_ref) {
       listRef.current.resetAfterIndex(0);
     }
   }, [searchQuery, activeGroup, activeTab]);
-  var getItemSize = function getItemSize(index) {
-    var item = currentItems && currentItems[index];
+  const getItemSize = (index) => {
+    const item = currentItems && currentItems[index];
     if (isListTitle(item)) {
       return ITEM_SIZE.title;
     }
     return ITEM_SIZE[itemSizes.DEFAULT];
   };
-  var hasTabs = tabs.length > 1;
-  var hasSearch = Boolean(searchQuery);
-  var dropdownContentHeight = useMemo(function () {
-    var fixedContentHeight = SEARCH_HEGIHT + (!hasSearch && hasTabs ? TABS_HEIGHT : 0) + (activeGroup ? SUBGROUP_HEADER_HEIGHT : 0);
+  const hasTabs = tabs.length > 1;
+  const hasSearch = Boolean(searchQuery);
+  const dropdownContentHeight = useMemo(() => {
+    const fixedContentHeight = SEARCH_HEGIHT + (!hasSearch && hasTabs ? TABS_HEIGHT : 0) + (activeGroup ? SUBGROUP_HEADER_HEIGHT : 0);
     return outerHeight - fixedContentHeight;
   }, [activeGroup, hasSearch, hasTabs, outerHeight]);
-  return /*#__PURE__*/React.createElement(Dropdown.Wrapper, {
-    "data-testid": "ds-factors-parameter-dropdown-wrapper",
-    ref: overlayRef,
-    onKeyDown: function onKeyDown(event) {
-      setSearchInputFocus(false);
-      searchQuery && focusWithArrowKeys(event, classNames.split(' ')[1], function () {
-        setSearchInputFocus(true);
-      });
-    }
-  }, /*#__PURE__*/React.createElement(Dropdown.SearchInput, {
-    onSearchChange: handleSearch,
-    onClearInput: function onClearInput() {
-      return handleSearch('');
-    },
-    placeholder: texts.parameter.searchPlaceholder,
-    value: searchQuery,
-    autofocus: !searchQuery || searchInputCanBeFocused,
-    autofocusDelay: 50,
-    iconLeft: /*#__PURE__*/React.createElement(Icon, {
-      component: /*#__PURE__*/React.createElement(SearchM, null),
-      color: theme.palette['grey-600']
-    })
-  }), tabs.length > 1 && /*#__PURE__*/React.createElement(S.TabsWrapper, null, /*#__PURE__*/React.createElement(Tabs, {
-    block: true,
-    tabs: tabs,
-    activeTab: activeTab,
-    handleTabClick: function handleTabClick(index) {
+  return /* @__PURE__ */ jsxs(Dropdown.Wrapper, { "data-testid": "ds-factors-parameter-dropdown-wrapper", ref: overlayRef, onKeyDown: (event) => {
+    setSearchInputFocus(false);
+    searchQuery && focusWithArrowKeys(event, classNames.split(" ")[1], () => {
+      setSearchInputFocus(true);
+    });
+  }, children: [
+    /* @__PURE__ */ jsx(Dropdown.SearchInput, { onSearchChange: handleSearch, onClearInput: () => handleSearch(""), placeholder: texts.parameter.searchPlaceholder, value: searchQuery, autofocus: !searchQuery || searchInputCanBeFocused, autofocusDelay: 50, iconLeft: /* @__PURE__ */ jsx(Icon, { component: /* @__PURE__ */ jsx(SearchM, {}), color: theme.palette["grey-600"] }) }),
+    tabs.length > 1 && /* @__PURE__ */ jsx(TabsWrapper, { children: /* @__PURE__ */ jsx(Tabs, { block: true, tabs, activeTab, handleTabClick: (index) => {
       setActiveTab(index);
-      setActiveGroup(undefined);
+      setActiveGroup(void 0);
       resetList();
-    }
-  })), activeGroup && /*#__PURE__*/React.createElement(Dropdown.BackAction, {
-    label: activeGroup.name,
-    onClick: function onClick() {
-      return setActiveGroup(undefined);
-    }
-  }), loading ? /*#__PURE__*/React.createElement(S.Skeleton, {
-    contentHeight: dropdownContentHeight,
-    size: "M",
-    numberOfSkeletons: 3
-  }) : /*#__PURE__*/React.createElement(S.ItemsList, {
-    contentHeight: dropdownContentHeight
-  }, currentItems != null && currentItems.length ? /*#__PURE__*/React.createElement(Scrollbar, {
-    absolute: true,
-    style: {
+    } }) }),
+    activeGroup && /* @__PURE__ */ jsx(Dropdown.BackAction, { label: activeGroup.name, onClick: () => setActiveGroup(void 0) }),
+    loading ? /* @__PURE__ */ jsx(Skeleton, { contentHeight: dropdownContentHeight, size: "M", numberOfSkeletons: 3 }) : /* @__PURE__ */ jsx(ItemsList, { contentHeight: dropdownContentHeight, children: currentItems?.length ? /* @__PURE__ */ jsx(Scrollbar, { absolute: true, style: {
       padding: 8
-    },
-    loading: loading,
-    hasMore: hasMoreItems,
-    onYReachEnd: onFetchData,
-    onScroll: handleScroll,
-    maxHeight: dropdownContentHeight,
-    ref: scrollBarRef
-  }, /*#__PURE__*/React.createElement(ListContextProvider, null, /*#__PURE__*/React.createElement(S.StyledList, {
-    width: "100%",
-    height: 300,
-    itemCount: currentItems.length,
-    itemSize: getItemSize,
-    style: LIST_STYLE,
-    ref: listRef
-  }, function (_ref3) {
-    var index = _ref3.index,
-      style = _ref3.style;
-    var listItem = currentItems[index];
-    if (listItem && isDivider(listItem)) {
-      return /*#__PURE__*/React.createElement("div", {
-        style: style
-      }, /*#__PURE__*/React.createElement(Divider, {
-        marginTop: 8,
-        marginBottom: 8
-      }));
-    }
-    return isListTitle(listItem) ? /*#__PURE__*/React.createElement(S.Title, {
-      style: style
-    }, listItem.title) : /*#__PURE__*/React.createElement(ParameterDropdownItem, _extends({
-      style: style
-    }, listItem));
-  }))) : getNoResultContainer));
+    }, loading, hasMore: hasMoreItems, onYReachEnd: onFetchData, onScroll: handleScroll, maxHeight: dropdownContentHeight, ref: scrollBarRef, children: /* @__PURE__ */ jsx(ListContextProvider, { children: /* @__PURE__ */ jsx(StyledList, { width: "100%", height: 300, itemCount: currentItems.length, itemSize: getItemSize, style: LIST_STYLE, ref: listRef, children: ({
+      index,
+      style
+    }) => {
+      const listItem = currentItems[index];
+      if (listItem && isDivider(listItem)) {
+        return /* @__PURE__ */ jsx("div", { style, children: /* @__PURE__ */ jsx(Divider, { marginTop: 8, marginBottom: 8 }) });
+      }
+      return isListTitle(listItem) ? /* @__PURE__ */ jsx(Title, { style, children: listItem.title }) : /* @__PURE__ */ jsx(ParameterDropdownItem, { style, ...listItem });
+    } }) }) }) : getNoResultContainer })
+  ] });
+};
+export {
+  ParameterDropdown as default
 };
-export default ParameterDropdown;

package/dist/FactorValue/Parameter/ParameterDropdownItem.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
-import { type ParameterGroup, type ParameterItem } from '../../Factors.types';
-import { type DropdownItem } from './Parameter.types';
+import { default as React } from 'react';
+import { ParameterGroup, ParameterItem } from '../../Factors.types';
+import { DropdownItem } from './Parameter.types';
 declare const ParameterDropdownItem: <ItemType extends ParameterItem | ParameterGroup>({ item, clearSearch, searchQuery, hideDropdown, select, className, style, label, }: DropdownItem<ItemType>) => React.JSX.Element;
 export default ParameterDropdownItem;

package/dist/FactorValue/Parameter/ParameterDropdownItem.js

@@ -1,34 +1,28 @@
-var _excluded = ["id", "icon"];
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-import React from 'react';
-import Icon from '@synerise/ds-icon';
-import ListItem from '@synerise/ds-list-item';
-var ParameterDropdownItem = function ParameterDropdownItem(_ref) {
-  var item = _ref.item,
-    clearSearch = _ref.clearSearch,
-    searchQuery = _ref.searchQuery,
-    hideDropdown = _ref.hideDropdown,
-    select = _ref.select,
-    className = _ref.className,
-    style = _ref.style,
-    label = _ref.label;
-  var id = item.id,
-    icon = item.icon,
-    itemProps = _objectWithoutPropertiesLoose(item, _excluded);
-  return /*#__PURE__*/React.createElement(ListItem, _extends({}, itemProps, {
-    style: style,
-    className: className,
-    key: item.name + item.id,
-    prefixel: /*#__PURE__*/React.createElement(Icon, {
-      component: icon
-    }),
-    highlight: searchQuery,
-    onClick: function onClick() {
-      clearSearch && clearSearch();
-      hideDropdown && hideDropdown();
-      select && select(item);
-    }
-  }), label || item.name);
+import { jsx } from "react/jsx-runtime";
+import { createElement } from "react";
+import Icon from "@synerise/ds-icon";
+import ListItem from "@synerise/ds-list-item";
+const ParameterDropdownItem = ({
+  item,
+  clearSearch,
+  searchQuery,
+  hideDropdown,
+  select,
+  className,
+  style,
+  label
+}) => {
+  const {
+    id,
+    icon,
+    ...itemProps
+  } = item;
+  return /* @__PURE__ */ createElement(ListItem, { ...itemProps, style, className, key: item.name + item.id, prefixel: /* @__PURE__ */ jsx(Icon, { component: icon }), highlight: searchQuery, onClick: () => {
+    clearSearch && clearSearch();
+    hideDropdown && hideDropdown();
+    select && select(item);
+  } }, label || item.name);
+};
+export {
+  ParameterDropdownItem as default
 };
-export default ParameterDropdownItem;

package/dist/FactorValue/Parameter/useGroups.d.ts

@@ -1,9 +1,9 @@
-import { type ParameterGroup, type ParameterItem } from '../../Factors.types';
+import { ParameterGroup, ParameterItem } from '../../Factors.types';
 export declare const useGroups: (items?: ParameterItem[], groups?: ParameterGroup[], renderEmptyGroups?: boolean) => {
     visibleGroups: ParameterGroup[] | undefined;
     tabs: {
         label: string;
-        icon: import("react").ReactNode;
+        icon: import('react').ReactNode;
     }[];
     defaultTab: number;
 };