cozy-sharing 32.1.2 → 32.3.1

package/dist/components/SharedDrive/SharedDriveModal copy.js

@@ -0,0 +1,356 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+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; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import PropTypes from 'prop-types';
+import React, { useState, useEffect } from 'react';
+import { useClient } from 'cozy-client';
+import Button from 'cozy-ui/transpiled/react/Buttons';
+import { FixedDialog } from 'cozy-ui/transpiled/react/CozyDialogs';
+import TextField from 'cozy-ui/transpiled/react/TextField';
+import Typography from 'cozy-ui/transpiled/react/Typography';
+import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert';
+import { useI18n } from 'cozy-ui/transpiled/react/providers/I18n';
+import { mergeAndDeduplicateRecipients, formatRecipients } from './helpers';
+import withLocales from '../../hoc/withLocales';
+import useContactsAndGroups from '../../hooks/useSharedDriveContactsAndGroups';
+import { useSharingContext } from '../../hooks/useSharingContext';
+import { Contact } from '../../models';
+import { buildSharingsByIdQuery } from '../../queries/queries';
+import { default as DumbShareByEmail } from '../ShareByEmail';
+import WhoHasAccess from '../WhoHasAccess';
+export var SharedDriveModal = withLocales( // ({ onClose, sharedDriveId = '59ee1637e38f3dbab1cbb7eb5f0a922a' }) => {
+function (_ref) {
+  var onClose = _ref.onClose,
+      sharedDrive = _ref.sharedDrive;
+  // ({ onClose, sharedDrive
+  var client = useClient();
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  var _useSharingContext = useSharingContext(),
+      share = _useSharingContext.share,
+      revoke = _useSharingContext.revoke;
+
+  var _useAlert = useAlert(),
+      showAlert = _useAlert.showAlert;
+
+  var isUpdate = Boolean(sharedDrive);
+
+  var _useContactsAndGroups = useContactsAndGroups([]),
+      contactsAndGroups = _useContactsAndGroups.contactsAndGroups,
+      isLoadingContactsAndGroups = _useContactsAndGroups.isLoading;
+
+  var _useState = useState({
+    recipients: [],
+    readOnlyRecipients: []
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      sharedDriveRecipients = _useState2[0],
+      setSharedDriveRecipients = _useState2[1];
+
+  var _useState3 = useState((sharedDrive === null || sharedDrive === void 0 ? void 0 : sharedDrive.name) || ''),
+      _useState4 = _slicedToArray(_useState3, 2),
+      sharedDriveName = _useState4[0],
+      setSharedDriveName = _useState4[1];
+
+  useEffect(function () {
+    if (sharedDrive && !isLoadingContactsAndGroups) {
+      setSharedDriveName(sharedDrive.rules[0].title);
+      setSharedDriveRecipients(separateMembersByPermission(associateToContacts(sharedDrive.members, contactsAndGroups)));
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [sharedDrive === null || sharedDrive === void 0 ? void 0 : sharedDrive._id, isLoadingContactsAndGroups]);
+
+  var onShare = function onShare(params) {
+    setSharedDriveRecipients({
+      recipients: mergeAndDeduplicateRecipients([sharedDriveRecipients.recipients, params.recipients]),
+      readOnlyRecipients: mergeAndDeduplicateRecipients([sharedDriveRecipients.readOnlyRecipients, params.readOnlyRecipients])
+    });
+  };
+
+  var handleSharedDriveNameChange = function handleSharedDriveNameChange(event) {
+    setSharedDriveName(event.target.value);
+  };
+
+  var onUpdate = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // TODO rename the shared drive
+            onClose();
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+
+    return function onUpdate() {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  var onCreate = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _yield$client$create2, sharedDriveFolder;
+
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            _context2.next = 3;
+            return client.collection('io.cozy.files').getOrCreateSharedDrivesDirectory();
+
+          case 3:
+            _context2.next = 5;
+            return client.create('io.cozy.files', {
+              name: sharedDriveName,
+              dirId: 'io.cozy.files.shared-drives-dir',
+              type: 'directory'
+            });
+
+          case 5:
+            _yield$client$create2 = _context2.sent;
+            sharedDriveFolder = _yield$client$create2.data;
+            _context2.next = 9;
+            return share({
+              document: sharedDriveFolder,
+              recipients: sharedDriveRecipients.recipients,
+              readOnlyRecipients: sharedDriveRecipients.readOnlyRecipients,
+              sharedDrive: true
+            });
+
+          case 9:
+            showAlert({
+              message: t('SharedDrive.sharedDriveModal.successNotification'),
+              severity: 'success',
+              variant: 'filled'
+            });
+            onClose();
+            _context2.next = 16;
+            break;
+
+          case 13:
+            _context2.prev = 13;
+            _context2.t0 = _context2["catch"](0);
+            showAlert({
+              message: t('SharedDrive.sharedDriveModal.errorNotification'),
+              severity: 'error',
+              variant: 'filled'
+            });
+
+          case 16:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[0, 13]]);
+    }));
+
+    return function onCreate() {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  var onSetType = function onSetType(index, newType) {
+    var _id = index.split('virtual-shared-drive-sharing-')[1];
+
+    if (newType === 'two-way') {
+      setSharedDriveRecipients(function (prev) {
+        var recipientToMove = prev.readOnlyRecipients.find(function (r) {
+          return r._id === _id;
+        });
+        return {
+          recipients: [].concat(_toConsumableArray(prev.recipients), [recipientToMove]),
+          readOnlyRecipients: prev.readOnlyRecipients.filter(function (r) {
+            return r._id !== _id;
+          })
+        };
+      });
+    } else {
+      setSharedDriveRecipients(function (prev) {
+        var recipientToMove = prev.recipients.find(function (r) {
+          return r._id === _id;
+        });
+        return {
+          recipients: prev.recipients.filter(function (r) {
+            return r._id !== _id;
+          }),
+          readOnlyRecipients: [].concat(_toConsumableArray(prev.readOnlyRecipients), [recipientToMove])
+        };
+      });
+    }
+  };
+
+  var onRevoke = /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(index) {
+      var _id;
+
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _id = index.split('virtual-shared-drive-sharing-')[1];
+            console.log('onRevoke', _id);
+            _context3.next = 4;
+            return revoke({
+              _id: _id
+            });
+
+          case 4:
+            console.log('onRevoke after revoke', _id);
+            setSharedDriveRecipients(function (prev) {
+              return {
+                recipients: prev.recipients.filter(function (r) {
+                  return r._id !== _id;
+                }),
+                readOnlyRecipients: prev.readOnlyRecipients.filter(function (r) {
+                  return r._id !== _id;
+                })
+              };
+            });
+
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+
+    return function onRevoke(_x) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+
+  var recipients = formatRecipients(sharedDriveRecipients);
+  return /*#__PURE__*/React.createElement(FixedDialog, {
+    open: true,
+    disableGutters: true,
+    onClose: onClose,
+    title: t("SharedDrive.sharedDriveModal.".concat(isUpdate ? 'updateTitle' : 'title')),
+    content: /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
+      className: "u-ph-2"
+    }, /*#__PURE__*/React.createElement(TextField, {
+      required: true,
+      label: t('SharedDrive.sharedDriveModal.nameLabel'),
+      variant: "outlined",
+      size: "small",
+      className: "u-w-100 u-mt-1-half",
+      value: sharedDriveName,
+      onChange: handleSharedDriveNameChange
+    }), /*#__PURE__*/React.createElement(Typography, {
+      variant: "h6",
+      className: "u-mt-1-half u-mb-half"
+    }, t('SharedDrive.sharedDriveModal.addPeople')), /*#__PURE__*/React.createElement(DumbShareByEmail, {
+      createContact: function createContact(contact) {
+        return client.create(Contact.doctype, contact);
+      },
+      currentRecipients: [],
+      document: document,
+      documentType: "Files",
+      onShare: onShare,
+      submitLabel: t('SharedDrive.sharedDriveModal.add'),
+      showNotifications: false
+    })), /*#__PURE__*/React.createElement(WhoHasAccess, {
+      isOwner: true,
+      recipients: recipients,
+      document: document,
+      documentType: "Files",
+      className: "u-w-100",
+      onRevoke: onRevoke,
+      onSetType: onSetType
+    })),
+    actions: /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Button, {
+      variant: "secondary",
+      label: t('SharedDrive.sharedDriveModal.cancel'),
+      onClick: onClose
+    }), /*#__PURE__*/React.createElement(Button, {
+      variant: "primary",
+      label: t('SharedDrive.sharedDriveModal.update'),
+      onClick: onUpdate
+    }), /*#__PURE__*/React.createElement(Button, {
+      variant: "primary",
+      label: t('SharedDrive.sharedDriveModal.create'),
+      onClick: onCreate
+    }))
+  });
+});
+SharedDriveModal.propTypes = {
+  onClose: PropTypes.func.isRequired
+};
+/**
+ * Separates sharing members into recipients and read-only recipients
+ * @param {Array} members - Array of sharing members
+ * @returns {Object} Object containing recipients and readOnlyRecipients arrays
+ */
+
+var separateMembersByPermission = function separateMembersByPermission(members) {
+  return members.reduce(function (acc, member) {
+    if (member.status !== 'owner') {
+      if (member.read_only === true) {
+        acc.readOnlyRecipients.push(member);
+      } else {
+        acc.recipients.push(member);
+      }
+    }
+
+    return acc;
+  }, {
+    recipients: [],
+    readOnlyRecipients: []
+  });
+};
+
+var associateToContacts = function associateToContacts(members, contacts) {
+  console.log('members', members);
+  console.log('contacts', contacts);
+  var result = [];
+
+  var _iterator = _createForOfIteratorHelper(members),
+      _step;
+
+  try {
+    var _loop = function _loop() {
+      var member = _step.value;
+
+      if (member.status !== 'owner' && member.email && member.instance) {
+        console.log('member', member);
+        var contact = contacts.find(function (c) {
+          var _c$email, _c$cozy;
+
+          return ((_c$email = c.email) === null || _c$email === void 0 ? void 0 : _c$email[0].address) === member.email && ((_c$cozy = c.cozy) === null || _c$cozy === void 0 || (_c$cozy = _c$cozy[0]) === null || _c$cozy === void 0 ? void 0 : _c$cozy.url) === member.instance;
+        });
+
+        if (contact) {
+          result.push(_objectSpread(_objectSpread({}, member), {}, {
+            _id: contact._id
+          }));
+        }
+      }
+    };
+
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return result;
+};

package/dist/components/SharedDrive/helpers.js

@@ -0,0 +1,102 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+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 { models } from 'cozy-client';
+var ContactModel = models.contact;
+export var RECIPIENT_INDEX_PREFIX = 'virtual-shared-drive-sharing-';
+export var mergeAndDeduplicateRecipients = function mergeAndDeduplicateRecipients(arrays) {
+  var combinedArray = arrays.flat().map(function (item) {
+    return _objectSpread(_objectSpread({}, item), {}, {
+      id: item.id || item._id
+    });
+  });
+  var seenIds = new Set();
+  var uniqueArray = combinedArray.reduce(function (acc, item) {
+    var id = item.id || item._id;
+
+    if (id == null) {
+      // Recipients without any identifier are kept as-is to avoid silent data loss
+      acc.push(item);
+      return acc;
+    }
+
+    if (!seenIds.has(id)) {
+      seenIds.add(id); // Ensure both id and _id exist for downstream compatibility
+
+      var normalizedItem = !item.id || !item._id ? _objectSpread(_objectSpread({}, item), {}, {
+        id: item.id || item._id,
+        _id: item._id || item.id
+      }) : item;
+      acc.push(normalizedItem);
+    }
+
+    return acc;
+  }, []);
+  return uniqueArray;
+};
+export var moveRecipientToReadWrite = function moveRecipientToReadWrite(federatedRecipients, _id) {
+  var recipientToMove = federatedRecipients.readOnlyRecipients.find(function (r) {
+    return r._id === _id;
+  });
+  if (!recipientToMove) return federatedRecipients;
+  return {
+    recipients: [].concat(_toConsumableArray(federatedRecipients.recipients), [recipientToMove]),
+    readOnlyRecipients: federatedRecipients.readOnlyRecipients.filter(function (r) {
+      return r._id !== _id;
+    })
+  };
+};
+export var moveRecipientToReadOnly = function moveRecipientToReadOnly(federatedRecipients, _id) {
+  var recipientToMove = federatedRecipients.recipients.find(function (r) {
+    return r._id === _id;
+  });
+  if (!recipientToMove) return federatedRecipients;
+  return {
+    recipients: federatedRecipients.recipients.filter(function (r) {
+      return r._id !== _id;
+    }),
+    readOnlyRecipients: [].concat(_toConsumableArray(federatedRecipients.readOnlyRecipients), [recipientToMove])
+  };
+};
+export var formatRecipients = function formatRecipients(sharedDriveRecipients) {
+  var recipients = [];
+  sharedDriveRecipients.recipients.forEach(function (r) {
+    recipients.push({
+      index: "".concat(RECIPIENT_INDEX_PREFIX).concat(r._id),
+      email: ContactModel.getPrimaryEmail(r),
+      public_name: r.displayName || r.name,
+      memberIndex: r._id,
+      type: 'two-way',
+      members: r.members
+    });
+  });
+  sharedDriveRecipients.readOnlyRecipients.forEach(function (r) {
+    recipients.push({
+      index: "".concat(RECIPIENT_INDEX_PREFIX).concat(r._id),
+      email: ContactModel.getPrimaryEmail(r),
+      public_name: r.displayName || r.name,
+      memberIndex: r._id,
+      type: 'one-way',
+      members: r.members
+    });
+  }); // We need to sort recipients by public_name
+  // to avoid reording them every time we change
+  // them from read only to read write.
+
+  recipients.sort(function (a, b) {
+    if (a.public_name < b.public_name) {
+      return -1;
+    }
+
+    if (a.public_name > b.public_name) {
+      return 1;
+    }
+
+    return 0;
+  });
+  return recipients;
+};

package/dist/components/SharedDrive/helpers.spec.js

@@ -0,0 +1,208 @@
+import { mergeAndDeduplicateRecipients, moveRecipientToReadWrite, moveRecipientToReadOnly, formatRecipients, RECIPIENT_INDEX_PREFIX } from './helpers';
+describe('mergeAndDeduplicateRecipients', function () {
+  it('should merge multiple arrays into one', function () {
+    var result = mergeAndDeduplicateRecipients([[{
+      id: '1',
+      name: 'Alice'
+    }], [{
+      id: '2',
+      name: 'Bob'
+    }]]);
+    expect(result).toEqual([{
+      id: '1',
+      _id: '1',
+      name: 'Alice'
+    }, {
+      id: '2',
+      _id: '2',
+      name: 'Bob'
+    }]);
+  });
+  it('should deduplicate recipients with the same id', function () {
+    var result = mergeAndDeduplicateRecipients([[{
+      id: '1',
+      name: 'Alice'
+    }], [{
+      id: '1',
+      name: 'Alice'
+    }]]);
+    expect(result).toEqual([{
+      id: '1',
+      _id: '1',
+      name: 'Alice'
+    }]);
+  });
+  it('should normalize _id to id for deduplication', function () {
+    var result = mergeAndDeduplicateRecipients([[{
+      _id: '1',
+      name: 'Alice'
+    }], [{
+      _id: '2',
+      name: 'Bob'
+    }]]);
+    expect(result).toEqual([{
+      _id: '1',
+      id: '1',
+      name: 'Alice'
+    }, {
+      _id: '2',
+      id: '2',
+      name: 'Bob'
+    }]);
+  });
+  it('should deduplicate recipients when one has id and the other has _id', function () {
+    var result = mergeAndDeduplicateRecipients([[{
+      id: '1',
+      name: 'Alice'
+    }], [{
+      _id: '1',
+      name: 'Alice'
+    }]]);
+    expect(result).toEqual([{
+      id: '1',
+      _id: '1',
+      name: 'Alice'
+    }]);
+  });
+  it('should prefer existing id over _id when both are present', function () {
+    var result = mergeAndDeduplicateRecipients([[{
+      id: 'real-id',
+      _id: 'other-id',
+      name: 'Alice'
+    }]]);
+    expect(result).toEqual([{
+      id: 'real-id',
+      _id: 'other-id',
+      name: 'Alice'
+    }]);
+  });
+  it('should handle empty arrays', function () {
+    var result = mergeAndDeduplicateRecipients([[], []]);
+    expect(result).toEqual([]);
+  });
+});
+describe('moveRecipientToReadWrite', function () {
+  it('should move a recipient from readOnly to readWrite', function () {
+    var state = {
+      recipients: [{
+        _id: '1',
+        name: 'Alice'
+      }],
+      readOnlyRecipients: [{
+        _id: '2',
+        name: 'Bob'
+      }]
+    };
+    var result = moveRecipientToReadWrite(state, '2');
+    expect(result.recipients).toEqual([{
+      _id: '1',
+      name: 'Alice'
+    }, {
+      _id: '2',
+      name: 'Bob'
+    }]);
+    expect(result.readOnlyRecipients).toEqual([]);
+  });
+  it('should return unchanged state if recipient not found', function () {
+    var state = {
+      recipients: [{
+        _id: '1',
+        name: 'Alice'
+      }],
+      readOnlyRecipients: []
+    };
+    var result = moveRecipientToReadWrite(state, '999');
+    expect(result).toBe(state);
+  });
+});
+describe('moveRecipientToReadOnly', function () {
+  it('should move a recipient from readWrite to readOnly', function () {
+    var state = {
+      recipients: [{
+        _id: '1',
+        name: 'Alice'
+      }],
+      readOnlyRecipients: [{
+        _id: '2',
+        name: 'Bob'
+      }]
+    };
+    var result = moveRecipientToReadOnly(state, '1');
+    expect(result.recipients).toEqual([]);
+    expect(result.readOnlyRecipients).toEqual([{
+      _id: '2',
+      name: 'Bob'
+    }, {
+      _id: '1',
+      name: 'Alice'
+    }]);
+  });
+  it('should return unchanged state if recipient not found', function () {
+    var state = {
+      recipients: [],
+      readOnlyRecipients: [{
+        _id: '1',
+        name: 'Alice'
+      }]
+    };
+    var result = moveRecipientToReadOnly(state, '999');
+    expect(result).toBe(state);
+  });
+});
+describe('formatRecipients', function () {
+  it('should format readWrite and readOnly recipients with correct types', function () {
+    var input = {
+      recipients: [{
+        _id: '1',
+        displayName: 'Alice',
+        email: [{
+          address: 'alice@example.com',
+          primary: true
+        }]
+      }],
+      readOnlyRecipients: [{
+        _id: '2',
+        displayName: 'Bob',
+        email: [{
+          address: 'bob@example.com',
+          primary: true
+        }]
+      }]
+    };
+    var result = formatRecipients(input);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({
+      index: "".concat(RECIPIENT_INDEX_PREFIX, "1"),
+      type: 'two-way',
+      public_name: 'Alice'
+    });
+    expect(result[1]).toMatchObject({
+      index: "".concat(RECIPIENT_INDEX_PREFIX, "2"),
+      type: 'one-way',
+      public_name: 'Bob'
+    });
+  });
+  it('should sort recipients by public_name', function () {
+    var input = {
+      recipients: [{
+        _id: '1',
+        displayName: 'Zara',
+        email: [{
+          address: 'zara@example.com',
+          primary: true
+        }]
+      }, {
+        _id: '2',
+        displayName: 'Alice',
+        email: [{
+          address: 'alice@example.com',
+          primary: true
+        }]
+      }],
+      readOnlyRecipients: []
+    };
+    var result = formatRecipients(input);
+    expect(result[0].public_name).toBe('Alice');
+    expect(result[1].public_name).toBe('Zara');
+  });
+});