cozy-sharing 40.1.9 → 40.2.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [40.2.0](https://github.com/cozy/cozy-libs/compare/cozy-sharing@40.1.9...cozy-sharing@40.2.0) (2026-10-28)
+
+### Bug Fixes
+
+- **cozy-sharing:** Ignore the email case when filtering suggestions ([4057cf0](https://github.com/cozy/cozy-libs/commit/4057cf010f54c646d8518aa787e03be445b60df2))
+
+### Features
+
+- **cozy-sharing:** Suggest recipients from the stack ([8b06972](https://github.com/cozy/cozy-libs/commit/8b0697256b118c365ca9f7315aae3f00eef6ebd6)), closes [linagora/twake-workplace-private#1929](https://github.com/linagora/twake-workplace-private/issues/1929)
+
 ## [40.1.9](https://github.com/cozy/cozy-libs/compare/cozy-sharing@40.1.8...cozy-sharing@40.1.9) (2026-10-28)
 
 ### Bug Fixes

package/README.md

@@ -40,6 +40,7 @@ import SharingProvider from 'cozy-sharing'
 | `onShared` | no | Callback fired after a share is created |
 | `isPublic` | no | Set to `true` when rendering a public page (disables fetching) |
 | `previewPath` | no | Custom preview path sent to the share creation |
+| `contactsSuggestEnabled` | no | Suggest the recipients with `GET /contacts/suggest` instead of loading every contact |
 
 ### Built-in components
 

package/dist/SharingProvider.js

@@ -1451,7 +1451,9 @@ export var SharingProvider = /*#__PURE__*/function (_Component) {
       // but if we don't, consumers don't rerender when the state changes after loading the sharings,
       // probably because the state object remains the same...
       return /*#__PURE__*/React.createElement(SharingContext.Provider, {
-        value: _objectSpread({}, this.state)
+        value: _objectSpread(_objectSpread({}, this.state), {}, {
+          contactsSuggestEnabled: this.props.contactsSuggestEnabled
+        })
       }, this.props.children);
     }
   }]);

package/dist/components/Recipient/PermissionTypeMenuWrapper.spec.js

@@ -208,7 +208,9 @@ describe('PermissionTypeMenu component', function () {
       }]
     };
     beforeEach(function () {
-      flag.mockReturnValue(true);
+      flag.mockImplementation(function (name) {
+        return name === 'drive.federated-shared-folder.enabled';
+      });
       mockHasSharedParent.mockReturnValue(true);
       mockGetSharingById.mockReturnValue({
         id: 'sharing-123',

package/dist/components/ShareAutosuggest.js

@@ -1,7 +1,10 @@
 import _extends from "@babel/runtime/helpers/extends";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import PropTypes from 'prop-types';
-import React, { useState, useRef } from 'react';
+import React, { useEffect, useState, useRef } from 'react';
 import Autosuggest from 'react-autosuggest';
 import Chip from 'cozy-ui/transpiled/react/Chips';
 import { Spinner } from 'cozy-ui/transpiled/react/Spinner';
@@ -10,6 +13,7 @@ import { MemberAvatar } from './Avatar/MemberAvatar';
 import ContactSuggestion from './ContactSuggestion';
 import { isContactToBeCreated } from '../helpers/contacts';
 import { extractEmails, validateEmail } from '../helpers/email';
+import logger from '../logger';
 import { getDisplayName, DOCTYPE_CONTACTS, DOCTYPE_GROUPS } from '../models';
 var styles = {
   "container": "autosuggest__container___1Yro7",
@@ -24,6 +28,8 @@ var styles = {
   "endAdornment": "autosuggest__endAdornment___2EwTN"
 };
 import { contactOrGroupMatch } from '../suggestionMatchers';
+var FETCH_CONTACTS_DEBOUNCE = 300;
+var FETCH_CONTACTS_MIN_LENGTH = 3;
 
 var ShareAutosuggest = function ShareAutosuggest(_ref) {
   var loading = _ref.loading,
@@ -35,7 +41,8 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
       enableCreateContact = _ref.enableCreateContact,
       placeholder = _ref.placeholder,
       autoFocus = _ref.autoFocus,
-      endAdornment = _ref.endAdornment;
+      endAdornment = _ref.endAdornment,
+      fetchContacts = _ref.fetchContacts;
 
   var _useState = useState(''),
       _useState2 = _slicedToArray(_useState, 2),
@@ -57,8 +64,20 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
       isLoadingDisplayed = _useState8[0],
       setLoadingDisplayed = _useState8[1];
 
+  var _useState9 = useState(false),
+      _useState10 = _slicedToArray(_useState9, 2),
+      isFetching = _useState10[0],
+      setIsFetching = _useState10[1];
+
   var autosuggestRef = useRef(null);
   var containerRef = useRef(null);
+  var fetchTimeoutRef = useRef(null);
+  var fetchedValueRef = useRef(null);
+  useEffect(function () {
+    return function () {
+      return clearTimeout(fetchTimeoutRef.current);
+    };
+  }, []);
 
   var computeSuggestions = function computeSuggestions(value) {
     var inputValue = value.trim().toLowerCase();
@@ -67,10 +86,7 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
     });
   };
 
-  var onSuggestionsFetchRequested = function onSuggestionsFetchRequested(_ref2) {
-    var value = _ref2.value;
-    var computedSuggestions = computeSuggestions(value);
-
+  var showSuggestions = function showSuggestions(computedSuggestions, value) {
     if (computedSuggestions.length > 0) {
       setSuggestions(computedSuggestions);
     } else if (enableCreateContact && validateEmail(value)) {
@@ -83,7 +99,63 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
     }
   };
 
+  var onSuggestionsFetchRequested = function onSuggestionsFetchRequested(_ref2) {
+    var value = _ref2.value;
+    var computedSuggestions = computeSuggestions(value);
+    clearTimeout(fetchTimeoutRef.current);
+    fetchedValueRef.current = value;
+
+    if (!fetchContacts || value.trim().length < FETCH_CONTACTS_MIN_LENGTH) {
+      setIsFetching(false);
+      showSuggestions(computedSuggestions, value);
+      return;
+    }
+
+    setIsFetching(true);
+    fetchTimeoutRef.current = setTimeout( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var contacts;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            contacts = [];
+            _context.prev = 1;
+            _context.next = 4;
+            return fetchContacts(value.trim());
+
+          case 4:
+            contacts = _context.sent;
+            _context.next = 10;
+            break;
+
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](1);
+            logger.error('Failed to fetch contact suggestions', _context.t0);
+
+          case 10:
+            if (!(fetchedValueRef.current !== value)) {
+              _context.next = 12;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 12:
+            setIsFetching(false);
+            showSuggestions([].concat(_toConsumableArray(contacts), _toConsumableArray(computedSuggestions)), value);
+
+          case 14:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[1, 7]]);
+    })), FETCH_CONTACTS_DEBOUNCE);
+  };
+
   var onSuggestionsClearRequested = function onSuggestionsClearRequested() {
+    clearTimeout(fetchTimeoutRef.current);
+    fetchedValueRef.current = null;
+    setIsFetching(false);
     setSuggestions([]);
   };
 
@@ -91,9 +163,9 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
     setIsPasted(true);
   };
 
-  var onAutosuggestChange = function onAutosuggestChange(event, _ref3) {
-    var newValue = _ref3.newValue,
-        method = _ref3.method;
+  var onAutosuggestChange = function onAutosuggestChange(event, _ref4) {
+    var newValue = _ref4.newValue,
+        method = _ref4.method;
 
     if (isPasted) {
       var emails = extractEmails(newValue);
@@ -126,9 +198,9 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
     }
   };
 
-  var onKeyUp = function onKeyUp(_ref4) {
-    var key = _ref4.key,
-        keyCode = _ref4.keyCode;
+  var onKeyUp = function onKeyUp(_ref5) {
+    var key = _ref5.key,
+        keyCode = _ref5.keyCode;
 
     if (recipients.length > 0 && inputValue === '' && (key === 'Backspace' || keyCode === 8 || key === 'Delete' || keyCode === 46)) {
       document.getElementById("recipient_".concat(recipients.length - 1)).focus();
@@ -202,7 +274,7 @@ var ShareAutosuggest = function ShareAutosuggest(_ref) {
     }), /*#__PURE__*/React.createElement("input", _extends({}, inputProps, {
       onKeyPress: onKeyPress,
       onKeyUp: onKeyUp
-    })), loading && isLoadingDisplayed ? /*#__PURE__*/React.createElement(Spinner, {
+    })), (loading || isFetching) && isLoadingDisplayed ? /*#__PURE__*/React.createElement(Spinner, {
       color: "var(--primaryColor)"
     }) : null, endAdornment ? /*#__PURE__*/React.createElement("div", {
       className: styles['endAdornment']
@@ -258,6 +330,7 @@ ShareAutosuggest.propTypes = {
   enableCreateContact: PropTypes.bool,
   placeholder: PropTypes.string,
   autoFocus: PropTypes.bool,
-  endAdornment: PropTypes.node
+  endAdornment: PropTypes.node,
+  fetchContacts: PropTypes.func
 };
 export default ShareAutosuggest;

package/dist/components/ShareAutosuggest.spec.js

@@ -1,4 +1,6 @@
-import { render, fireEvent, screen } from '@testing-library/react';
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, render, fireEvent, screen } from '@testing-library/react';
 import React from 'react';
 import ShareAutosuggest from './ShareAutosuggest';
 import AppLike from '../../test/AppLike';
@@ -16,7 +18,8 @@ describe('ShareAutosuggest', function () {
         _ref$loading = _ref.loading,
         loading = _ref$loading === void 0 ? false : _ref$loading,
         _ref$enableCreateCont = _ref.enableCreateContact,
-        enableCreateContact = _ref$enableCreateCont === void 0 ? true : _ref$enableCreateCont;
+        enableCreateContact = _ref$enableCreateCont === void 0 ? true : _ref$enableCreateCont,
+        fetchContacts = _ref.fetchContacts;
     render( /*#__PURE__*/React.createElement(AppLike, null, /*#__PURE__*/React.createElement(ShareAutosuggest, {
       loading: loading,
       contactsAndGroups: [],
@@ -24,7 +27,8 @@ describe('ShareAutosuggest', function () {
       onPick: onPick,
       recipients: [],
       onRemove: onRemove,
-      enableCreateContact: enableCreateContact
+      enableCreateContact: enableCreateContact,
+      fetchContacts: fetchContacts
     })));
   };
 
@@ -123,4 +127,120 @@ describe('ShareAutosuggest', function () {
     });
     expect(screen.queryByText('loading')).toBeNull();
   });
+  describe('with fetchContacts', function () {
+    beforeEach(function () {
+      jest.useFakeTimers(); // Not implemented by jsdom, called when a suggestion is highlighted
+
+      Element.prototype.scrollIntoView = jest.fn();
+    });
+    afterEach(function () {
+      jest.useRealTimers();
+    });
+    it('should suggest the fetched contacts, debounced and from 3 characters', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var fetchContacts, inputNode;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            fetchContacts = jest.fn().mockResolvedValue([{
+              _id: 'org-member-1',
+              _type: 'io.cozy.contacts',
+              displayName: 'Jean Dupont',
+              email: [{
+                address: 'jean@org.example',
+                primary: true
+              }]
+            }]);
+            setup({
+              onPick: jest.fn(),
+              onRemove: jest.fn(),
+              fetchContacts: fetchContacts
+            });
+            inputNode = screen.getByPlaceholderText('myPlaceHolder');
+            fireEvent.change(inputNode, {
+              target: {
+                value: 'du'
+              }
+            });
+            act(function () {
+              return jest.runAllTimers();
+            });
+            expect(fetchContacts).not.toHaveBeenCalled();
+            fireEvent.change(inputNode, {
+              target: {
+                value: 'dup'
+              }
+            });
+            fireEvent.change(inputNode, {
+              target: {
+                value: 'dupo'
+              }
+            });
+            act(function () {
+              return jest.runAllTimers();
+            });
+            expect(fetchContacts).toHaveBeenCalledTimes(1);
+            expect(fetchContacts).toHaveBeenCalledWith('dupo');
+            _context.t0 = expect;
+            _context.next = 14;
+            return screen.findByText('Jean Dupont');
+
+          case 14:
+            _context.t1 = _context.sent;
+            (0, _context.t0)(_context.t1).toBeInTheDocument();
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('should show the loading indicator until the contacts are fetched', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var resolveFetch, fetchContacts, inputNode;
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            fetchContacts = jest.fn(function () {
+              return new Promise(function (resolve) {
+                return resolveFetch = resolve;
+              });
+            });
+            setup({
+              onPick: jest.fn(),
+              onRemove: jest.fn(),
+              fetchContacts: fetchContacts
+            });
+            inputNode = screen.getByPlaceholderText('myPlaceHolder');
+            fireEvent.change(inputNode, {
+              target: {
+                value: 'dup'
+              }
+            });
+            expect(screen.getByText('loading')).toBeInTheDocument();
+            act(function () {
+              return jest.runAllTimers();
+            });
+            _context3.next = 8;
+            return act( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+              return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    return _context2.abrupt("return", resolveFetch([]));
+
+                  case 1:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2);
+            })));
+
+          case 8:
+            expect(screen.queryByText('loading')).toBeNull();
+
+          case 9:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
 });

package/dist/components/ShareAutosuggestWrapper.js

@@ -1,4 +1,6 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 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; }
 
@@ -6,18 +8,25 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 import PropTypes from 'prop-types';
 import React from 'react';
-import { useQueryAll, isQueryLoading } from 'cozy-client';
+import { useClient, useQueryAll, isQueryLoading } from 'cozy-client';
+import { models } from 'cozy-client';
 import flag from 'cozy-flags';
 import ShareAutosuggest from './ShareAutosuggest';
-import { computeContactsAndGroups } from '../helpers/contacts';
+import { computeContactsAndGroups, suggestContacts } from '../helpers/contacts';
+import { useSharingContext } from '../hooks/useSharingContext';
+import { DOCTYPE_GROUPS } from '../models';
 import { buildReachableContactsQuery, buildContactGroupsQuery, buildUnreachableContactsWithGroupsQuery } from '../queries/queries';
+var ContactModel = models.contact;
 /**
  * ShareAutosuggestWrapper is responsible for fetching contacts and groups.
  * We retrieve all the contacts that are reachable and the groups they belong to.
  * In order to display the total number of members in each group, we also retrieve the contacts that are not reachable.
+ * With contactsSuggestEnabled, the stack suggests the contacts and we only retrieve the group members.
  */
 
 var ShareAutosuggestWrapper = function ShareAutosuggestWrapper(_ref) {
+  var _useSharingContext;
+
   var currentRecipients = _ref.currentRecipients,
       recipients = _ref.recipients,
       placeholder = _ref.placeholder,
@@ -27,7 +36,11 @@ var ShareAutosuggestWrapper = function ShareAutosuggestWrapper(_ref) {
       disabled = _ref.disabled,
       autoFocus = _ref.autoFocus,
       endAdornment = _ref.endAdornment;
-  var reachableContactsQuery = buildReachableContactsQuery();
+  var client = useClient();
+  var contactsSuggestEnabled = (_useSharingContext = useSharingContext()) === null || _useSharingContext === void 0 ? void 0 : _useSharingContext.contactsSuggestEnabled;
+  var reachableContactsQuery = buildReachableContactsQuery({
+    inGroups: contactsSuggestEnabled
+  });
   var reachableContactsResult = useQueryAll(reachableContactsQuery.definition, reachableContactsQuery.options);
   var unreachableContactsWithGroupsQuery = buildUnreachableContactsWithGroupsQuery();
   var unreachableContactsWithGroupsResult = useQueryAll(unreachableContactsWithGroupsQuery.definition, _objectSpread(_objectSpread({}, unreachableContactsWithGroupsQuery.options), {}, {
@@ -36,13 +49,55 @@ var ShareAutosuggestWrapper = function ShareAutosuggestWrapper(_ref) {
   var contactGroupsQuery = buildContactGroupsQuery();
   var contactGroupsResult = useQueryAll(contactGroupsQuery.definition, contactGroupsQuery.options);
   var isLoading = isQueryLoading(reachableContactsResult) || reachableContactsResult.hasMore || isQueryLoading(contactGroupsResult) || contactGroupsResult.hasMore || flag('sharing.show-recipient-groups') && (isQueryLoading(unreachableContactsWithGroupsResult) || unreachableContactsWithGroupsResult.hasMore);
-  var contactsAndGroups = computeContactsAndGroups({
+  var suggestedContactsAndGroups = computeContactsAndGroups({
     reachableContacts: reachableContactsResult.data || [],
     unreachableContactsWithGroups: unreachableContactsWithGroupsResult.data || [],
     contactGroups: contactGroupsResult.data || [],
     currentRecipients: currentRecipients,
     pendingRecipients: recipients
   });
+  var contactsAndGroups = contactsSuggestEnabled ? suggestedContactsAndGroups.filter(function (_ref2) {
+    var _type = _ref2._type;
+    return _type === DOCTYPE_GROUPS;
+  }) : suggestedContactsAndGroups; // The stack matches the emails whatever their case
+
+  var normalizeEmail = function normalizeEmail(email) {
+    return email === null || email === void 0 ? void 0 : email.trim().toLowerCase();
+  };
+
+  var isRecipient = function isRecipient(email) {
+    return currentRecipients.some(function (r) {
+      return normalizeEmail(r.email) === email;
+    }) || recipients.some(function (r) {
+      return normalizeEmail(ContactModel.getPrimaryEmail(r)) === email;
+    });
+  };
+
+  var fetchContacts = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(q) {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return suggestContacts(client, q);
+
+          case 2:
+            return _context.abrupt("return", _context.sent.filter(function (contact) {
+              return !isRecipient(normalizeEmail(ContactModel.getPrimaryEmail(contact)));
+            }));
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+
+    return function fetchContacts(_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
   return /*#__PURE__*/React.createElement(ShareAutosuggest, {
     loading: isLoading,
     disabled: disabled,
@@ -53,7 +108,8 @@ var ShareAutosuggestWrapper = function ShareAutosuggestWrapper(_ref) {
     enableCreateContact: enableCreateContact,
     placeholder: placeholder,
     autoFocus: autoFocus,
-    endAdornment: endAdornment
+    endAdornment: endAdornment,
+    fetchContacts: contactsSuggestEnabled ? fetchContacts : undefined
   });
 };
 

package/dist/components/ShareAutosuggestWrapper.spec.js

@@ -14,11 +14,13 @@ jest.mock('cozy-flags', function () {
     })
   };
 });
+var mockAutosuggestProps;
 jest.mock('./ShareAutosuggest', function () {
   return {
     __esModule: true,
-    default: function _default(_ref) {
-      var contactsAndGroups = _ref.contactsAndGroups;
+    default: function _default(props) {
+      mockAutosuggestProps = props;
+      var contactsAndGroups = props.contactsAndGroups;
       return /*#__PURE__*/React.createElement("ul", null, contactsAndGroups.map(function (contactOrGroup) {
         if (contactOrGroup._type === 'io.cozy.contacts') {
           return /*#__PURE__*/React.createElement("li", {
@@ -34,14 +36,16 @@ jest.mock('./ShareAutosuggest', function () {
   };
 });
 describe('ShareAutosuggestWrapper component', function () {
-  var setup = function setup(_ref2) {
-    var contacts = _ref2.contacts,
-        contactGroups = _ref2.contactGroups,
-        unreachableContact = _ref2.unreachableContact;
+  var setup = function setup(_ref) {
+    var contacts = _ref.contacts,
+        contactGroups = _ref.contactGroups,
+        unreachableContact = _ref.unreachableContact,
+        groupMembers = _ref.groupMembers;
 
-    var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        currentRecipients = _ref3.currentRecipients,
-        recipients = _ref3.recipients;
+    var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        currentRecipients = _ref2.currentRecipients,
+        recipients = _ref2.recipients,
+        contactsSuggestEnabled = _ref2.contactsSuggestEnabled;
 
     var mockClient = createMockClient({
       queries: {
@@ -56,11 +60,18 @@ describe('ShareAutosuggestWrapper component', function () {
         'io.cozy.contacts/unreachable-with-groups': {
           doctype: 'io.cozy.contacts',
           data: unreachableContact
+        },
+        'io.cozy.contacts/reachable-with-groups': {
+          doctype: 'io.cozy.contacts',
+          data: groupMembers
         }
       }
     });
     render( /*#__PURE__*/React.createElement(AppLike, {
-      client: mockClient
+      client: mockClient,
+      sharingContextValue: {
+        contactsSuggestEnabled: contactsSuggestEnabled
+      }
     }, /*#__PURE__*/React.createElement(ShareAutosuggestWrapper, {
       onPick: function onPick() {},
       onRemove: function onRemove() {},
@@ -68,6 +79,7 @@ describe('ShareAutosuggestWrapper component', function () {
       currentRecipients: currentRecipients,
       recipients: recipients
     })));
+    return mockClient;
   };
 
   it('should include groups and contacts when are loaded', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
@@ -240,7 +252,9 @@ describe('ShareAutosuggestWrapper component', function () {
     return _regeneratorRuntime.wrap(function _callee4$(_context4) {
       while (1) switch (_context4.prev = _context4.next) {
         case 0:
-          flag.mockReturnValue(true);
+          flag.mockImplementation(function (name) {
+            return name === 'sharing.show-recipient-groups';
+          });
           contacts = [{
             id: 'df563cc4-6440',
             _id: 'df563cc4-6440',
@@ -307,4 +321,92 @@ describe('ShareAutosuggestWrapper component', function () {
       }
     }, _callee4);
   })));
+  describe('with contactsSuggestEnabled', function () {
+    beforeEach(function () {
+      flag.mockReset();
+    });
+    it('should suggest only groups, with the count of their members', function () {
+      var groupMembers = [{
+        id: '5a3b4ccf-c257',
+        _id: '5a3b4ccf-c257',
+        _type: 'io.cozy.contacts',
+        name: {
+          givenName: 'Teagan',
+          familyName: 'Wolf'
+        },
+        relationships: {
+          groups: {
+            data: [{
+              _id: 'fe86af20-c6c5',
+              _type: 'io.cozy.contacts.groups'
+            }]
+          }
+        }
+      }];
+      var contactGroups = [{
+        id: 'fe86af20-c6c5',
+        _id: 'fe86af20-c6c5',
+        _type: 'io.cozy.contacts.groups',
+        name: 'Friends'
+      }];
+      setup({
+        contactGroups: contactGroups,
+        groupMembers: groupMembers
+      }, {
+        contactsSuggestEnabled: true
+      });
+      expect(screen.getByText('Friends - 1 members')).toBeInTheDocument();
+      expect(screen.queryByText('Teagan Wolf')).not.toBeInTheDocument();
+    });
+    it('should fetch suggestions without the current and pending recipients, whatever the case of their email', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+      var suggestion, mockClient, fetchJSON, contacts;
+      return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            suggestion = function suggestion(email) {
+              return {
+                type: 'io.cozy.contacts',
+                attributes: {
+                  fullname: email,
+                  email: [{
+                    address: email
+                  }]
+                }
+              };
+            };
+
+            mockClient = setup({
+              contactGroups: [],
+              groupMembers: []
+            }, {
+              currentRecipients: [{
+                email: 'Current@Cozy.cc'
+              }],
+              recipients: [{
+                email: 'pending@cozy.cc'
+              }],
+              contactsSuggestEnabled: true
+            });
+            fetchJSON = jest.fn().mockResolvedValue({
+              data: [suggestion('current@cozy.cc'), suggestion('PENDING@cozy.cc'), suggestion('new@cozy.cc')]
+            });
+            jest.spyOn(mockClient, 'getStackClient').mockReturnValue({
+              fetchJSON: fetchJSON
+            });
+            _context5.next = 6;
+            return mockAutosuggestProps.fetchContacts('coz');
+
+          case 6:
+            contacts = _context5.sent;
+            expect(contacts.map(function (c) {
+              return c.fullname;
+            })).toEqual(['new@cozy.cc']);
+
+          case 8:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+  });
 });