cozy-sharing 40.1.9 → 40.2.1

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,11 @@ describe('ShareAutosuggest', function () {
       onPick: onPick,
       recipients: [],
       onRemove: onRemove,
-      enableCreateContact: enableCreateContact
+      enableCreateContact: enableCreateContact,
+      fetchContacts: fetchContacts,
+      getAvatarUrl: function getAvatarUrl() {
+        return null;
+      }
     })));
   };
 
@@ -123,4 +130,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/ShareAutosuggest.stories.js

@@ -37,6 +37,9 @@ export var Default = {
   render: ShareAutosuggestRender,
   args: {
     loading: false,
+    getAvatarUrl: function getAvatarUrl() {
+      return null;
+    },
     contactsAndGroups: [{
       id: 'group1',
       name: 'Family',

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,26 @@ 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 { makeAvatarUrl } from '../helpers/recipients';
+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 +37,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 +50,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 +109,11 @@ var ShareAutosuggestWrapper = function ShareAutosuggestWrapper(_ref) {
     enableCreateContact: enableCreateContact,
     placeholder: placeholder,
     autoFocus: autoFocus,
-    endAdornment: endAdornment
+    endAdornment: endAdornment,
+    fetchContacts: contactsSuggestEnabled ? fetchContacts : undefined,
+    getAvatarUrl: function getAvatarUrl(recipient) {
+      return makeAvatarUrl(recipient, client.options.uri);
+    }
   });
 };
 

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);
+    })));
+  });
 });

package/dist/components/WhoHasAccessWrapper.js

@@ -7,7 +7,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 import React from 'react';
 import { useClient, useQuery, hasQueryBeenLoaded } from 'cozy-client';
 import WhoHasAccess from './WhoHasAccess';
-import { hasMemberActions, markCurrentUser } from '../helpers/recipients';
+import { addAvatarUrls, hasMemberActions, makeAvatarUrl, markCurrentUser } from '../helpers/recipients';
 import { useMemberPermissionType } from '../hooks/useMemberPermissionType';
 import { useSharingContext } from '../hooks/useSharingContext';
 import { buildInstanceSettingsQuery } from '../queries/queries'; // When the owner is not part of a sharing's members (eg. the folder only has
@@ -53,7 +53,7 @@ var WhoHasAccessWrapper = function WhoHasAccessWrapper(_ref) {
       revokeSelf = _useSharingContext.revokeSelf;
 
   var instanceUri = client.options.uri;
-  var markedRecipients = markCurrentUser(recipients, instanceUri);
+  var markedRecipients = addAvatarUrls(markCurrentUser(recipients, instanceUri), instanceUri);
   var hasMemberMenus = markedRecipients.some(function (recipient) {
     return !recipient.members && !recipientsToBeConfirmed.some(function (user) {
       return user.email === recipient.email;
@@ -85,6 +85,10 @@ var WhoHasAccessWrapper = function WhoHasAccessWrapper(_ref) {
     status: 'owner',
     instance: instanceUri,
     avatarPath: OWNER_PUBLIC_AVATAR_PATH,
+    avatarUrl: makeAvatarUrl({
+      status: 'owner',
+      avatarPath: OWNER_PUBLIC_AVATAR_PATH
+    }, instanceUri),
     public_name: (_instanceSettingsResu = instanceSettingsResult.data) === null || _instanceSettingsResu === void 0 || (_instanceSettingsResu = _instanceSettingsResu.attributes) === null || _instanceSettingsResu === void 0 ? void 0 : _instanceSettingsResu.public_name
   } : null;
   var owner = ownerRecipient ? _objectSpread(_objectSpread({}, ownerRecipient), {}, {

package/dist/helpers/contacts.js

@@ -10,16 +10,35 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { models } from 'cozy-client';
 import flag from 'cozy-flags';
 import { validateEmail } from '../helpers/email';
+import { DOCTYPE_CONTACTS, DOCTYPE_GROUPS } from '../models';
 var ContactModel = models.contact; // Return the contact object if present
 // Else check if a contact exist with this email address, if yes return it
 // if not create it
+// With contactsSuggestEnabled, people are sent by email and the
+// stack finds or creates the contact: an org member's id is not on this instance
 
 export var getOrCreateFromArray = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(client, contacts, createContact) {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(client, contacts, createContact, contactsSuggestEnabled) {
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          _context2.next = 2;
+          if (!contactsSuggestEnabled) {
+            _context2.next = 2;
+            break;
+          }
+
+          return _context2.abrupt("return", contacts.map(function (contact) {
+            if (contact._type === DOCTYPE_GROUPS) return contact;
+            var email = ContactModel.getPrimaryEmail(contact);
+            if (validateEmail(email)) return {
+              _type: DOCTYPE_CONTACTS,
+              email: email
+            };
+            return contact._id ? contact : undefined;
+          }));
+
+        case 2:
+          _context2.next = 4;
           return Promise.all(contacts.map( /*#__PURE__*/function () {
             var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(contact) {
               var matchedContact, resp;
@@ -83,24 +102,64 @@ export var getOrCreateFromArray = /*#__PURE__*/function () {
               }, _callee);
             }));
 
-            return function (_x4) {
+            return function (_x5) {
               return _ref2.apply(this, arguments);
             };
           }()));
 
-        case 2:
+        case 4:
           return _context2.abrupt("return", _context2.sent);
 
-        case 3:
+        case 5:
         case "end":
           return _context2.stop();
       }
     }, _callee2);
   }));
 
-  return function getOrCreateFromArray(_x, _x2, _x3) {
+  return function getOrCreateFromArray(_x, _x2, _x3, _x4) {
     return _ref.apply(this, arguments);
   };
+}(); // A suggestion without id has no contact document, and only a fullname,
+// which getDisplayName does not read
+
+export var suggestContacts = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(client, q) {
+    var _yield$client$getStac, data;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return client.getStackClient().fetchJSON('GET', "/contacts/suggest?q=".concat(encodeURIComponent(q)));
+
+        case 2:
+          _yield$client$getStac = _context3.sent;
+          data = _yield$client$getStac.data;
+          return _context3.abrupt("return", data.map(function (_ref4) {
+            var id = _ref4.id,
+                type = _ref4.type,
+                attributes = _ref4.attributes;
+            return _objectSpread(_objectSpread(_objectSpread({}, attributes), id ? {
+              _id: id,
+              id: id
+            } : {
+              displayName: attributes.fullname
+            }), {}, {
+              _type: type
+            });
+          }));
+
+        case 5:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+
+  return function suggestContacts(_x6, _x7) {
+    return _ref3.apply(this, arguments);
+  };
 }();
 export var getContactsFromGroupId = function getContactsFromGroupId() {
   var contacts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
@@ -144,12 +203,12 @@ var isCurrentUser = function isCurrentUser(contact) {
  */
 
 
-export var computeContactsAndGroups = function computeContactsAndGroups(_ref3) {
-  var reachableContacts = _ref3.reachableContacts,
-      unreachableContactsWithGroups = _ref3.unreachableContactsWithGroups,
-      contactGroups = _ref3.contactGroups,
-      currentRecipients = _ref3.currentRecipients,
-      pendingRecipients = _ref3.pendingRecipients;
+export var computeContactsAndGroups = function computeContactsAndGroups(_ref5) {
+  var reachableContacts = _ref5.reachableContacts,
+      unreachableContactsWithGroups = _ref5.unreachableContactsWithGroups,
+      contactGroups = _ref5.contactGroups,
+      currentRecipients = _ref5.currentRecipients,
+      pendingRecipients = _ref5.pendingRecipients;
   var suggestedContacts = reachableContacts.filter(function (contact) {
     return !isCurrentUser(contact) && // We do not want contact already in the sharing
     !currentRecipients.find(function (r) {
@@ -162,12 +221,12 @@ export var computeContactsAndGroups = function computeContactsAndGroups(_ref3) {
   var unreachableContacts = unreachableContactsWithGroups.filter(function (contact) {
     return !isCurrentUser(contact);
   });
-  var currentRecipientGroups = currentRecipients.map(function (_ref4) {
-    var id = _ref4.id;
+  var currentRecipientGroups = currentRecipients.map(function (_ref6) {
+    var id = _ref6.id;
     return id;
   }).filter(Boolean);
-  var suggestedGroups = contactGroups.filter(function (_ref5) {
-    var _id = _ref5._id;
+  var suggestedGroups = contactGroups.filter(function (_ref7) {
+    var _id = _ref7._id;
     return !flag('sharing.show-recipient-groups') || !currentRecipientGroups.includes(_id);
   }).map(function (contactGroup) {
     var reachableMembers = getContactsFromGroupId(suggestedContacts, contactGroup.id).map(function (contact) {