cozy-ui 127.11.0 → 127.13.0

package/react/ContactsList/helpers.js

@@ -32,10 +32,10 @@ export const sortContacts = contacts => contacts.sort(sortLastNameFirst)
  * @returns {string} header
  */
 const makeHeader = (contact, t) => {
-  if (contact.me) return t('me')
+  if (contact.me) return t('ContactsList.me')
 
   const name = buildLastNameFirst(contact)
-  return name[0] || t('empty')
+  return name[0] || t('ContactsList.empty')
 }
 
 /**
@@ -45,8 +45,8 @@ const makeHeader = (contact, t) => {
  * @returns {string} header
  */
 const makeHeaderForIndexedContacts = (contact, t) => {
-  if (contact.me) return t('me')
-  if (contact.cozyMetadata?.favorite) return t('favorite')
+  if (contact.me) return t('ContactsList.me')
+  if (contact.cozyMetadata?.favorite) return t('ContactsList.favorite')
 
   const index = get(contact, 'indexes.byFamilyNameGivenNameEmailCozyUrl', '')
   const hasIndex = index !== null && index.length > 0
@@ -58,7 +58,7 @@ const makeHeaderForIndexedContacts = (contact, t) => {
     return firstLetterWithoutAccent
   }
 
-  return t('empty')
+  return t('ContactsList.empty')
 }
 
 /**
@@ -89,7 +89,8 @@ export const categorizeContacts = (contacts, t) =>
 export const sortHeaders = (categorized, t) => {
   const headers = Object.keys(categorized)
   const notEmptyAndMyselfHeaders = headers.filter(
-    header => header !== t('empty') && header !== t('me')
+    header =>
+      header !== t('ContactsList.empty') && header !== t('ContactsList.me')
   )
   const notEmptyAndMyselfSorted = notEmptyAndMyselfHeaders.slice().sort()
 
@@ -98,11 +99,11 @@ export const sortHeaders = (categorized, t) => {
   }
 
   const headersSorted = []
-  if (headers.includes(t('me'))) {
-    headersSorted.push(t('me'))
+  if (headers.includes(t('ContactsList.me'))) {
+    headersSorted.push(t('ContactsList.me'))
   }
-  if (headers.includes(t('empty'))) {
-    headersSorted.push(t('empty'))
+  if (headers.includes(t('ContactsList.empty'))) {
+    headersSorted.push(t('ContactsList.empty'))
   }
 
   return headersSorted.concat(notEmptyAndMyselfSorted)

package/react/ContactsList/helpers.spec.js

@@ -103,7 +103,7 @@ describe('sortHeaders', () => {
 
     const sortedHeaders = sortHeaders(contacts, t)
 
-    expect(sortedHeaders).toEqual(['me', 'empty', 'B', 'F', 'H'])
+    expect(sortedHeaders).toEqual(['B', 'F', 'H', 'empty', 'me'])
   })
 })
 
@@ -143,7 +143,16 @@ describe('makeGroupLabelsAndCounts', () => {
     const res = makeGroupLabelsAndCounts(contacts, t)
 
     expect(res).toStrictEqual({
-      groupLabels: ['A', 'C', 'B', 'X', 'Z', 'empty', 'me', 'E'],
+      groupLabels: [
+        'A',
+        'C',
+        'B',
+        'X',
+        'Z',
+        'ContactsList.empty',
+        'ContactsList.me',
+        'E'
+      ],
       groupCounts: [3, 5, 2, 1, 1, 4, 1, 1]
     })
   })

package/react/ContactsList/locales/en.json

@@ -1,6 +1,8 @@
 {
-  "empty": "EMPTY",
-  "me": "me",
-  "favorite": "favorites",
-  "menu": "Menu"
+  "ContactsList": {
+    "empty": "EMPTY",
+    "me": "me",
+    "favorite": "favorites",
+    "menu": "Menu"
+  }
 }

package/react/ContactsList/locales/fr.json

@@ -1,6 +1,8 @@
 {
-  "empty": "VIDE",
-  "me": "moi",
-  "favorite": "favoris",
-  "menu": "Menu"
-}
+  "ContactsList": {
+    "empty": "VIDE",
+    "me": "moi",
+    "favorite": "favoris",
+    "menu": "Menu"
+  }
+}

package/transpiled/react/Contacts/GroupsSelect/GroupCreation.d.ts

@@ -0,0 +1,3 @@
+declare var _default: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+export default _default;
+import React from "react";

package/transpiled/react/Contacts/GroupsSelect/GroupCreation.js

@@ -0,0 +1,133 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import classNames from 'classnames';
+import React, { Component } from 'react';
+var styles = {};
+import Icon from "cozy-ui/transpiled/react/Icon";
+import PlusIcon from "cozy-ui/transpiled/react/Icons/Plus";
+import Input from "cozy-ui/transpiled/react/Input";
+import { translate } from "cozy-ui/transpiled/react/providers/I18n";
+
+var normalizeGroupData = function normalizeGroupData(name) {
+  return {
+    name: name,
+    metadata: {
+      version: 1
+    }
+  };
+};
+
+var GroupCreation = /*#__PURE__*/function (_Component) {
+  _inherits(GroupCreation, _Component);
+
+  var _super = _createSuper(GroupCreation);
+
+  function GroupCreation(props) {
+    var _this;
+
+    _classCallCheck(this, GroupCreation);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      isInputDisplayed: false,
+      groupName: ''
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleClick", function () {
+      _this.setState({
+        isInputDisplayed: !_this.state.isInputDisplayed
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onFocus", function (e) {
+      e.stopPropagation();
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onClick", function (e) {
+      e.stopPropagation();
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "keyPress", /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(e) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (e.keyCode == 13) {
+                  _this.props.createGroup(normalizeGroupData(e.target.value));
+
+                  _this.textInput.current.value = '';
+                }
+
+                e.stopPropagation();
+
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+
+    _defineProperty(_assertThisInitialized(_this), "onMouseDown", function (e) {
+      e.stopPropagation();
+    });
+
+    _this.textInput = /*#__PURE__*/React.createRef();
+    return _this;
+  }
+
+  _createClass(GroupCreation, [{
+    key: "render",
+    value: function render() {
+      var isInputDisplayed = this.state.isInputDisplayed;
+      var t = this.props.t;
+      return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
+        className: styles['contact-group-creation-divider']
+      }), /*#__PURE__*/React.createElement("div", {
+        className: classNames('u-ml-half', 'u-mr-half', 'u-c-pointer', styles['container'])
+      }, !isInputDisplayed && /*#__PURE__*/React.createElement("div", {
+        onClick: this.handleClick,
+        className: styles['contact-group-create-div-icon']
+      }, /*#__PURE__*/React.createElement(Icon, {
+        icon: PlusIcon
+      }), /*#__PURE__*/React.createElement("span", {
+        className: "u-pl-half"
+      }, t('Contacts.GroupsSelect.create'))), isInputDisplayed && /*#__PURE__*/React.createElement(Input, {
+        id: "createGroupInput",
+        ref: this.textInput,
+        type: "text",
+        placeholder: t('Contacts.GroupsSelect.name'),
+        onClick: this.onClick,
+        onFocus: this.onFocus,
+        onKeyDown: this.keyPress,
+        size: "tiny",
+        autoComplete: "off",
+        autoFocus: true,
+        onMouseDown: this.onMouseDown
+      })));
+    }
+  }]);
+
+  return GroupCreation;
+}(Component);
+
+export default translate()(GroupCreation);

package/transpiled/react/Contacts/GroupsSelect/GroupsSelect.d.ts

@@ -0,0 +1,56 @@
+export function GroupsSelect({ allGroups, closeMenuOnSelect, value, styles, isMulti, noOptionsMessage, withCheckbox, components, onGroupCreated, onChange, onGroupCreate, onGroupUpdate, onGroupDelete, menuPosition }: {
+    allGroups: any;
+    closeMenuOnSelect: any;
+    value: any;
+    styles: any;
+    isMulti: any;
+    noOptionsMessage: any;
+    withCheckbox: any;
+    components: any;
+    onGroupCreated: any;
+    onChange: any;
+    onGroupCreate: any;
+    onGroupUpdate: any;
+    onGroupDelete: any;
+    menuPosition: any;
+}): JSX.Element;
+export namespace GroupsSelect {
+    const propTypes: {
+        allGroups: PropTypes.Validator<any[]>;
+        styles: PropTypes.Requireable<object>;
+        value: PropTypes.Validator<object>;
+        components: PropTypes.Requireable<object>;
+        isMulti: PropTypes.Requireable<boolean>;
+        noOptionsMessage: PropTypes.Requireable<(...args: any[]) => any>;
+        withCheckbox: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Validator<(...args: any[]) => any>;
+        onGroupCreated: PropTypes.Requireable<(...args: any[]) => any>;
+        onGroupCreate: PropTypes.Requireable<(...args: any[]) => any>;
+        onGroupUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onGroupDelete: PropTypes.Requireable<(...args: any[]) => any>;
+        closeMenuOnSelect: PropTypes.Requireable<boolean>;
+        menuPosition: PropTypes.Requireable<string>;
+    } | {
+        allGroups: PropTypes.Validator<any[]>;
+        onGroupCreate: PropTypes.Validator<(...args: any[]) => any>;
+        onGroupUpdate: PropTypes.Validator<(...args: any[]) => any>;
+        onGroupDelete: PropTypes.Validator<(...args: any[]) => any>;
+        styles?: undefined;
+        value?: undefined;
+        components?: undefined;
+        isMulti?: undefined;
+        noOptionsMessage?: undefined;
+        withCheckbox?: undefined;
+        onChange?: undefined;
+        onGroupCreated?: undefined;
+        closeMenuOnSelect?: undefined;
+        menuPosition?: undefined;
+    };
+    namespace defaultProps {
+        const isMulti: boolean;
+        const components: {};
+        const closeMenuOnSelect: boolean;
+    }
+}
+export default GroupsSelect;
+import PropTypes from "prop-types";

package/transpiled/react/Contacts/GroupsSelect/GroupsSelect.js

@@ -0,0 +1,181 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+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; }
+
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { useClient } from 'cozy-client';
+import CustomMenu from "cozy-ui/transpiled/react/Contacts/GroupsSelect/SelectBox/Menu";
+import CustomOption from "cozy-ui/transpiled/react/Contacts/GroupsSelect/SelectBox/Option";
+import CustomSelectContainer from "cozy-ui/transpiled/react/Contacts/GroupsSelect/SelectBox/SelectContainer";
+import useGroupsSelect from "cozy-ui/transpiled/react/Contacts/GroupsSelect/useGroupSelect";
+import ClickAwayListener from "cozy-ui/transpiled/react/ClickAwayListener";
+import SelectBox from "cozy-ui/transpiled/react/SelectBox";
+import { useBreakpoints } from "cozy-ui/transpiled/react/providers/Breakpoints";
+
+var captureEscapeEvent = function captureEscapeEvent(e) {
+  if (e.key === 'Escape') {
+    e.stopPropagation();
+    e.target.blur();
+  }
+};
+
+export var GroupsSelect = function GroupsSelect(_ref) {
+  var allGroups = _ref.allGroups,
+      closeMenuOnSelect = _ref.closeMenuOnSelect,
+      value = _ref.value,
+      styles = _ref.styles,
+      isMulti = _ref.isMulti,
+      noOptionsMessage = _ref.noOptionsMessage,
+      withCheckbox = _ref.withCheckbox,
+      components = _ref.components,
+      onGroupCreated = _ref.onGroupCreated,
+      onChange = _ref.onChange,
+      onGroupCreate = _ref.onGroupCreate,
+      onGroupUpdate = _ref.onGroupUpdate,
+      onGroupDelete = _ref.onGroupDelete,
+      menuPosition = _ref.menuPosition;
+  var client = useClient();
+
+  var _useBreakpoints = useBreakpoints(),
+      isMobile = _useBreakpoints.isMobile;
+
+  var _useState = useState({
+    menuIsOpen: false,
+    editedGroupId: ''
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      _useState2$ = _useState2[0],
+      menuIsOpen = _useState2$.menuIsOpen,
+      editedGroupId = _useState2$.editedGroupId,
+      setState = _useState2[1];
+
+  var _useGroupsSelect = useGroupsSelect({
+    allGroups: allGroups,
+    onGroupCreated: onGroupCreated,
+    client: client,
+    onGroupCreate: onGroupCreate,
+    onGroupUpdate: onGroupUpdate
+  }),
+      createGroup = _useGroupsSelect.createGroup,
+      renameGroup = _useGroupsSelect.renameGroup;
+
+  var toggleMenu = function toggleMenu() {
+    setState(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, {
+        menuIsOpen: !prev.menuIsOpen
+      });
+    });
+  };
+
+  var closeMenu = function closeMenu() {
+    setState(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, {
+        menuIsOpen: false
+      });
+    });
+  };
+
+  var setEditedGroupId = function setEditedGroupId(id) {
+    setState(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, {
+        editedGroupId: id
+      });
+    });
+  };
+
+  var handleChange = function handleChange(props) {
+    if (closeMenuOnSelect) {
+      closeMenu();
+    }
+
+    onChange(props);
+  };
+
+  var handleDelete = function handleDelete(group) {
+    closeMenu();
+    onGroupDelete(group);
+  };
+
+  var defaultComponents = {
+    Menu: CustomMenu,
+    Option: CustomOption,
+    SelectContainer: CustomSelectContainer
+  };
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(ClickAwayListener, {
+    onClickAway: menuIsOpen ? closeMenu : function () {}
+  }, /*#__PURE__*/React.createElement(SelectBox, {
+    className: isMobile ? 'u-mb-half' : 'u-mr-half',
+    classNamePrefix: "react-select",
+    isMulti: isMulti,
+    withCheckbox: withCheckbox,
+    menuIsOpen: menuIsOpen,
+    blurInputOnSelect: true,
+    hideSelectedOptions: false,
+    isSearchable: false,
+    isClearable: false,
+    closeMenuOnSelect: closeMenuOnSelect,
+    tabSelectsValue: false,
+    onKeyDown: captureEscapeEvent,
+    noOptionsMessage: noOptionsMessage,
+    options: allGroups,
+    value: value,
+    onChange: handleChange,
+    getOptionLabel: function getOptionLabel(group) {
+      return group.name;
+    },
+    getOptionValue: function getOptionValue(group) {
+      return group._id;
+    },
+    components: _objectSpread(_objectSpread({}, defaultComponents), components),
+    createGroup: createGroup,
+    deleteGroup: handleDelete,
+    renameGroup: renameGroup,
+    styles: styles,
+    onControlClicked: toggleMenu,
+    setEditedGroupId: setEditedGroupId,
+    editedGroupId: editedGroupId,
+    menuPosition: menuPosition,
+    fullwidth: true
+  })));
+};
+GroupsSelect.propTypes = {
+  allGroups: PropTypes.array.isRequired,
+  styles: PropTypes.object,
+  // for multiple selections, value can be an array
+  value: PropTypes.oneOfType([PropTypes.array, PropTypes.object]).isRequired,
+  // to customize react-select elements
+  components: PropTypes.object,
+  // to define if it is possible to select more than one option
+  isMulti: PropTypes.bool,
+  // noOptionsMessage is used to show a message when there is no options in the menu list
+  noOptionsMessage: PropTypes.func,
+  // hide/show checkbox besides menu list options
+  withCheckbox: PropTypes.bool,
+  onChange: PropTypes.func.isRequired,
+  // function to be triggered after creating a group
+  onGroupCreated: PropTypes.func,
+  // function to be triggered when creating a group
+  onGroupCreate: PropTypes.func,
+  // function to be triggered when updating a group
+  onGroupUpdate: PropTypes.func,
+  // function to be triggered when deleting a group
+  onGroupDelete: PropTypes.func,
+  closeMenuOnSelect: PropTypes.bool,
+  menuPosition: PropTypes.oneOf(['fixed', 'absolute'])
+};
+GroupsSelect.defaultProps = {
+  isMulti: false,
+  components: {},
+  closeMenuOnSelect: false
+};
+GroupsSelect.propTypes = {
+  allGroups: PropTypes.array.isRequired,
+  onGroupCreate: PropTypes.func.isRequired,
+  onGroupUpdate: PropTypes.func.isRequired,
+  onGroupDelete: PropTypes.func.isRequired
+};
+export default GroupsSelect;

package/transpiled/react/Contacts/GroupsSelect/GroupsSelect.spec.d.ts

@@ -0,0 +1,22 @@
+export const groups: {
+    id: string;
+    _id: string;
+    _type: string;
+    _rev: string;
+    cozyMetadata: {
+        createdAt: string;
+        createdByApp: string;
+        createdByAppVersion: string;
+        metadataVersion: number;
+        updatedAt: string;
+        updatedByApps: {
+            date: string;
+            slug: string;
+            version: string;
+        }[];
+    };
+    metadata: {
+        version: number;
+    };
+    name: string;
+}[];

package/transpiled/react/Contacts/GroupsSelect/GroupsSelectProvider.d.ts

@@ -0,0 +1,5 @@
+export function useSelectedGroup(): any;
+export default SelectedGroupProvider;
+declare function SelectedGroupProvider({ children }: {
+    children: any;
+}): JSX.Element;

package/transpiled/react/Contacts/GroupsSelect/GroupsSelectProvider.js

@@ -0,0 +1,38 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import React, { useContext, useState } from 'react';
+import { translatedDefaultSelectedGroup } from "cozy-ui/transpiled/react/Contacts/GroupsSelect/helpers";
+import { locales } from "cozy-ui/transpiled/react/Contacts/GroupsSelect/locales";
+import { useI18n, useExtendI18n } from "cozy-ui/transpiled/react/providers/I18n";
+var SelectedGroupContext = /*#__PURE__*/React.createContext();
+export var useSelectedGroup = function useSelectedGroup() {
+  var context = useContext(SelectedGroupContext);
+
+  if (!context) {
+    throw new Error('useSelectedGroup must be used within a SelectedGroupProvider');
+  }
+
+  return context;
+};
+
+var SelectedGroupProvider = function SelectedGroupProvider(_ref) {
+  var children = _ref.children;
+  useExtendI18n(locales);
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  var _useState = useState(translatedDefaultSelectedGroup(t)),
+      _useState2 = _slicedToArray(_useState, 2),
+      selectedGroup = _useState2[0],
+      setSelectedGroup = _useState2[1];
+
+  var contextValue = {
+    selectedGroup: selectedGroup,
+    setSelectedGroup: setSelectedGroup
+  };
+  return /*#__PURE__*/React.createElement(SelectedGroupContext.Provider, {
+    value: contextValue
+  }, children);
+};
+
+export default SelectedGroupProvider;

package/transpiled/react/Contacts/GroupsSelect/SelectBox/Control.d.ts

@@ -0,0 +1,14 @@
+export default Control;
+declare function Control({ innerRef, innerProps, selectProps: { onControlClicked } }: {
+    innerRef: any;
+    innerProps: any;
+    selectProps: {
+        onControlClicked: any;
+    };
+}): JSX.Element;
+declare namespace Control {
+    namespace propTypes {
+        const selectProps: PropTypes.Validator<object>;
+    }
+}
+import PropTypes from "prop-types";

package/transpiled/react/Contacts/GroupsSelect/SelectBox/Control.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime/helpers/extends";
+import PropTypes from 'prop-types';
+import React from 'react';
+import Button from "cozy-ui/transpiled/react/Buttons";
+import Icon from "cozy-ui/transpiled/react/Icon";
+import BottomSelectIcon from "cozy-ui/transpiled/react/Icons/BottomSelect";
+import { useI18n, useExtendI18n } from "cozy-ui/transpiled/react/providers/I18n";
+import { locales } from "cozy-ui/transpiled/react/Contacts/GroupsSelect/locales";
+
+var Control = function Control(_ref) {
+  var innerRef = _ref.innerRef,
+      innerProps = _ref.innerProps,
+      onControlClicked = _ref.selectProps.onControlClicked;
+  useExtendI18n(locales);
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  return /*#__PURE__*/React.createElement("div", _extends({
+    ref: innerRef
+  }, innerProps), /*#__PURE__*/React.createElement(Button, {
+    variant: "secondary",
+    size: "small",
+    onClick: onControlClicked,
+    onTouchStart: onControlClicked,
+    label: t('Contacts.GroupsSelect.manage'),
+    startIcon: /*#__PURE__*/React.createElement(Icon, {
+      icon: BottomSelectIcon,
+      width: "12"
+    })
+  }));
+};
+
+Control.propTypes = {
+  selectProps: PropTypes.object.isRequired
+};
+export default Control;

package/transpiled/react/Contacts/GroupsSelect/SelectBox/EditGroupName.d.ts

@@ -0,0 +1,7 @@
+export default EditGroupName;
+declare function EditGroupName({ groupId, groupName, setEditedGroupId, renameGroup }: {
+    groupId: any;
+    groupName: any;
+    setEditedGroupId: any;
+    renameGroup: any;
+}): JSX.Element;