cozy-sharing 40.1.6 → 40.1.8

package/dist/components/WhoHasAccessWrapper.js

@@ -0,0 +1,122 @@
+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 React from 'react';
+import { useClient, useQuery, hasQueryBeenLoaded } from 'cozy-client';
+import WhoHasAccess from './WhoHasAccess';
+import { hasMemberActions, 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
+// a link), there is no per-sharing avatar to reference. The instance's public
+// avatar still holds the owner's picture. fallback=initials makes the stack
+// serve a generated initials avatar (instead of the app icon) when no picture
+// has been uploaded, matching how avatars are rendered everywhere else.
+
+var OWNER_PUBLIC_AVATAR_PATH = '/public/avatar?fallback=initials';
+
+var WhoHasAccessWrapper = function WhoHasAccessWrapper(_ref) {
+  var _instanceSettingsResu;
+
+  var _ref$isOwner = _ref.isOwner,
+      isOwner = _ref$isOwner === void 0 ? false : _ref$isOwner,
+      _ref$canManageSharing = _ref.canManageSharing,
+      canManageSharing = _ref$canManageSharing === void 0 ? isOwner : _ref$canManageSharing,
+      isSharedDrive = _ref.isSharedDrive,
+      isReadOnly = _ref.isReadOnly,
+      _ref$canManageMembers = _ref.canManageMembers,
+      canManageMembers = _ref$canManageMembers === void 0 ? !isReadOnly : _ref$canManageMembers,
+      canManageLink = _ref.canManageLink,
+      _ref$showOwner = _ref.showOwner,
+      showOwner = _ref$showOwner === void 0 ? true : _ref$showOwner,
+      recipients = _ref.recipients,
+      _ref$recipientsToBeCo = _ref.recipientsToBeConfirmed,
+      recipientsToBeConfirmed = _ref$recipientsToBeCo === void 0 ? [] : _ref$recipientsToBeCo,
+      document = _ref.document,
+      documentType = _ref.documentType,
+      className = _ref.className,
+      onRevoke = _ref.onRevoke,
+      onRevokeSelf = _ref.onRevokeSelf,
+      verifyRecipient = _ref.verifyRecipient,
+      link = _ref.link;
+  var client = useClient();
+
+  var _useSharingContext = useSharingContext(),
+      isOrgSharedDrive = _useSharingContext.isOrgSharedDrive,
+      getDocumentPermissions = _useSharingContext.getDocumentPermissions,
+      updateDocumentPermissions = _useSharingContext.updateDocumentPermissions,
+      revokeSharingLink = _useSharingContext.revokeSharingLink,
+      revokeGroup = _useSharingContext.revokeGroup,
+      revokeSelf = _useSharingContext.revokeSelf;
+
+  var instanceUri = client.options.uri;
+  var markedRecipients = markCurrentUser(recipients, instanceUri);
+  var hasMemberMenus = markedRecipients.some(function (recipient) {
+    return !recipient.members && !recipientsToBeConfirmed.some(function (user) {
+      return user.email === recipient.email;
+    }) && hasMemberActions({
+      status: recipient.status,
+      isCurrentUser: recipient.isCurrentUser,
+      isOwner: isOwner,
+      canManageSharing: canManageSharing,
+      canManageMembers: canManageMembers
+    });
+  });
+
+  var _useMemberPermissionT = useMemberPermissionType(document, {
+    shouldFetchPath: hasMemberMenus
+  }),
+      isInsideSharedParent = _useMemberPermissionT.isInsideSharedParent,
+      sharedParentName = _useMemberPermissionT.sharedParentName,
+      setMemberType = _useMemberPermissionT.setMemberType;
+
+  var ownerRecipient = markedRecipients.find(function (recipient) {
+    return recipient.status === 'owner';
+  });
+  var instanceSettingsQuery = buildInstanceSettingsQuery();
+  var instanceSettingsResult = useQuery(instanceSettingsQuery.definition, _objectSpread(_objectSpread({}, instanceSettingsQuery.options), {}, {
+    enabled: showOwner && !ownerRecipient
+  }));
+  var defaultOwner = hasQueryBeenLoaded(instanceSettingsResult) ? {
+    isOwner: true,
+    status: 'owner',
+    instance: instanceUri,
+    avatarPath: OWNER_PUBLIC_AVATAR_PATH,
+    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), {}, {
+    isOrgSharedDrive: isOrgSharedDrive(document === null || document === void 0 ? void 0 : document._id)
+  }) : defaultOwner;
+  return /*#__PURE__*/React.createElement(WhoHasAccess, {
+    isOwner: isOwner,
+    canManageSharing: canManageSharing,
+    isSharedDrive: isSharedDrive,
+    isReadOnly: isReadOnly,
+    canManageMembers: canManageMembers,
+    canManageLink: canManageLink,
+    showOwner: showOwner,
+    owner: owner,
+    isInsideSharedParent: isInsideSharedParent,
+    sharedParentName: sharedParentName,
+    recipients: markedRecipients,
+    recipientsToBeConfirmed: recipientsToBeConfirmed,
+    document: document,
+    documentType: documentType,
+    className: className,
+    onRevoke: onRevoke,
+    onRevokeSelf: onRevokeSelf,
+    onRevokeGroup: revokeGroup,
+    onLeaveGroup: revokeSelf,
+    onSetMemberType: setMemberType,
+    onUpdateLinkPermissions: updateDocumentPermissions,
+    onRevokeLink: revokeSharingLink,
+    verifyRecipient: verifyRecipient,
+    link: link,
+    permissions: getDocumentPermissions(document === null || document === void 0 ? void 0 : document._id)
+  });
+};
+
+export default WhoHasAccessWrapper;

package/dist/helpers/contacts.js

@@ -1,6 +1,16 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+
+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 _regeneratorRuntime from "@babel/runtime/regenerator";
-import { validateEmail } from '../helpers/email'; // Return the contact object if present
+import { models } from 'cozy-client';
+import flag from 'cozy-flags';
+import { validateEmail } from '../helpers/email';
+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
 
@@ -114,4 +124,72 @@ export var getContactsFromGroupId = function getContactsFromGroupId() {
 
 export var isContactToBeCreated = function isContactToBeCreated(contact) {
   return !contact._id;
+};
+
+var isCurrentUser = function isCurrentUser(contact) {
+  return contact.me === true;
+};
+/**
+ * Computes the contacts and groups to suggest when adding recipients to a
+ * sharing. The unreachable contacts only count in the members of the groups,
+ * when flag sharing.show-recipient-groups is enabled.
+ *
+ * @param {object} params
+ * @param {object[]} params.reachableContacts - Contacts that can be shared with
+ * @param {object[]} params.unreachableContactsWithGroups - Contacts that cannot be shared with but belong to a group
+ * @param {object[]} params.contactGroups - Groups of contacts
+ * @param {object[]} params.currentRecipients - Recipients already in the sharing
+ * @param {object[]} params.pendingRecipients - Recipients picked but not yet shared with
+ * @returns {object[]} The contacts, then the groups with their members
+ */
+
+
+export var computeContactsAndGroups = function computeContactsAndGroups(_ref3) {
+  var reachableContacts = _ref3.reachableContacts,
+      unreachableContactsWithGroups = _ref3.unreachableContactsWithGroups,
+      contactGroups = _ref3.contactGroups,
+      currentRecipients = _ref3.currentRecipients,
+      pendingRecipients = _ref3.pendingRecipients;
+  var suggestedContacts = reachableContacts.filter(function (contact) {
+    return !isCurrentUser(contact) && // We do not want contact already in the sharing
+    !currentRecipients.find(function (r) {
+      return r.email === ContactModel.getPrimaryEmail(contact);
+    }) && // We do not want contact currently in pending contacts (in chips)
+    !pendingRecipients.find(function (r) {
+      return r._id === contact._id;
+    });
+  });
+  var unreachableContacts = unreachableContactsWithGroups.filter(function (contact) {
+    return !isCurrentUser(contact);
+  });
+  var currentRecipientGroups = currentRecipients.map(function (_ref4) {
+    var id = _ref4.id;
+    return id;
+  }).filter(Boolean);
+  var suggestedGroups = contactGroups.filter(function (_ref5) {
+    var _id = _ref5._id;
+    return !flag('sharing.show-recipient-groups') || !currentRecipientGroups.includes(_id);
+  }).map(function (contactGroup) {
+    var reachableMembers = getContactsFromGroupId(suggestedContacts, contactGroup.id).map(function (contact) {
+      return _objectSpread(_objectSpread({}, contact), {}, {
+        isReachable: true
+      });
+    });
+
+    if (flag('sharing.show-recipient-groups') !== true) {
+      return _objectSpread(_objectSpread({}, contactGroup), {}, {
+        members: reachableMembers
+      });
+    }
+
+    var unreachableMembers = getContactsFromGroupId(unreachableContacts, contactGroup.id).map(function (contact) {
+      return _objectSpread(_objectSpread({}, contact), {}, {
+        isReachable: false
+      });
+    });
+    return _objectSpread(_objectSpread({}, contactGroup), {}, {
+      members: [].concat(_toConsumableArray(reachableMembers), _toConsumableArray(unreachableMembers))
+    });
+  });
+  return [].concat(_toConsumableArray(suggestedContacts), _toConsumableArray(suggestedGroups));
 };

package/dist/helpers/contacts.spec.js

@@ -1,6 +1,22 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+
+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 _regeneratorRuntime from "@babel/runtime/regenerator";
-import { getOrCreateFromArray } from './contacts';
+import flag from 'cozy-flags';
+import { computeContactsAndGroups, getOrCreateFromArray } from './contacts';
+jest.mock('cozy-flags', function () {
+  return {
+    __esModule: true,
+    default: jest.fn(function () {
+      return null;
+    })
+  };
+});
 var findMock = jest.fn().mockReturnValueOnce({
   data: [{
     id: 2,
@@ -63,4 +79,109 @@ describe('getOrCreateFromArray', function () {
       }
     }, _callee);
   })));
+});
+describe('computeContactsAndGroups', function () {
+  var group = {
+    id: 'friends',
+    _id: 'friends',
+    name: 'Friends'
+  };
+  var inGroup = {
+    relationships: {
+      groups: {
+        data: [{
+          _id: 'friends'
+        }]
+      }
+    }
+  };
+
+  var alice = _objectSpread({
+    _id: 'alice',
+    email: [{
+      address: 'alice@cozy.cc',
+      primary: true
+    }]
+  }, inGroup);
+
+  var bob = _objectSpread({
+    _id: 'bob',
+    email: [{
+      address: 'bob@cozy.cc'
+    }]
+  }, inGroup);
+
+  var me = _objectSpread({
+    _id: 'me',
+    me: true
+  }, inGroup);
+
+  var carol = _objectSpread({
+    _id: 'carol'
+  }, inGroup);
+
+  var setup = function setup() {
+    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref2$currentRecipien = _ref2.currentRecipients,
+        currentRecipients = _ref2$currentRecipien === void 0 ? [] : _ref2$currentRecipien,
+        _ref2$pendingRecipien = _ref2.pendingRecipients,
+        pendingRecipients = _ref2$pendingRecipien === void 0 ? [] : _ref2$pendingRecipien,
+        _ref2$showRecipientGr = _ref2.showRecipientGroups,
+        showRecipientGroups = _ref2$showRecipientGr === void 0 ? null : _ref2$showRecipientGr;
+
+    flag.mockReturnValue(showRecipientGroups);
+    return computeContactsAndGroups({
+      reachableContacts: [alice, bob, me],
+      unreachableContactsWithGroups: [carol, me],
+      contactGroups: [group],
+      currentRecipients: currentRecipients,
+      pendingRecipients: pendingRecipients
+    });
+  };
+
+  it('suggests the contacts, then the groups with their reachable members', function () {
+    var _setup = setup(),
+        _setup2 = _slicedToArray(_setup, 3),
+        first = _setup2[0],
+        second = _setup2[1],
+        friends = _setup2[2];
+
+    expect([first._id, second._id, friends._id]).toEqual(['alice', 'bob', 'friends']);
+    expect(friends.members.map(function (m) {
+      return [m._id, m.isReachable];
+    })).toEqual([['alice', true], ['bob', true]]);
+  });
+  it('does not suggest the recipients already shared with or picked', function () {
+    var contactsAndGroups = setup({
+      currentRecipients: [{
+        email: 'alice@cozy.cc'
+      }],
+      pendingRecipients: [bob]
+    });
+    expect(contactsAndGroups.map(function (c) {
+      return c._id;
+    })).toEqual(['friends']);
+  });
+  it('adds the unreachable members when flag sharing.show-recipient-groups is enabled', function () {
+    var _setup3 = setup({
+      showRecipientGroups: true
+    }),
+        _setup4 = _slicedToArray(_setup3, 3),
+        friends = _setup4[2];
+
+    expect(friends.members.map(function (m) {
+      return [m._id, m.isReachable];
+    })).toEqual([['alice', true], ['bob', true], ['carol', false]]);
+  });
+  it('does not suggest the groups already in the sharing when flag sharing.show-recipient-groups is enabled', function () {
+    var contactsAndGroups = setup({
+      currentRecipients: [{
+        id: 'friends'
+      }],
+      showRecipientGroups: true
+    });
+    expect(contactsAndGroups.map(function (c) {
+      return c._id;
+    })).toEqual(['alice', 'bob']);
+  });
 });

package/dist/helpers/recipients.js

@@ -95,4 +95,50 @@ export var getGroupRecipientSecondaryText = function getGroupRecipientSecondaryT
     smart_count: nbMember
   });
   return secondary + (isUserInsideMembers ? " (".concat(t('GroupRecipient.secondary_you'), ")") : '');
+};
+
+var isInstance = function isInstance(recipient, instanceUri) {
+  return recipient.instance !== undefined && recipient.instance === instanceUri;
+};
+/**
+ * Flags with `isCurrentUser` the recipients, and the members of group
+ * recipients, whose instance is the current user's one
+ *
+ * @param {object[]} recipients - Recipients of a sharing
+ * @param {string} instanceUri - URI of the current user's instance
+ * @returns {object[]} The recipients with their `isCurrentUser` flag
+ */
+
+
+export var markCurrentUser = function markCurrentUser(recipients, instanceUri) {
+  return recipients.map(function (recipient) {
+    return _objectSpread(_objectSpread({}, recipient), {}, {
+      isCurrentUser: isInstance(recipient, instanceUri)
+    }, recipient.members && {
+      members: recipient.members.map(function (member) {
+        return _objectSpread(_objectSpread({}, member), {}, {
+          isCurrentUser: isInstance(member, instanceUri)
+        });
+      })
+    });
+  });
+};
+/**
+ * @param {object} params
+ * @param {string} params.status - Status of the member in the sharing
+ * @param {boolean} params.isCurrentUser - Whether the member is the current user
+ * @param {boolean} params.isOwner - Whether the current user owns the sharing
+ * @param {boolean} params.canManageSharing - Whether the current user can manage the sharing
+ * @param {boolean} params.canManageMembers - Whether the members can be managed
+ * @returns {boolean} Whether the current user can change the member's
+ * permission type or revoke them
+ */
+
+export var hasMemberActions = function hasMemberActions(_ref2) {
+  var status = _ref2.status,
+      isCurrentUser = _ref2.isCurrentUser,
+      isOwner = _ref2.isOwner,
+      canManageSharing = _ref2.canManageSharing,
+      canManageMembers = _ref2.canManageMembers;
+  return canManageMembers && status !== 'owner' && (isCurrentUser && !isOwner || canManageSharing);
 };

package/dist/helpers/recipients.spec.js

@@ -0,0 +1,89 @@
+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 { hasMemberActions, markCurrentUser } from './recipients';
+var instanceUri = 'https://alice.cozy.cc';
+describe('markCurrentUser', function () {
+  it('flags the recipient whose instance is the current one', function () {
+    var recipients = [{
+      email: 'alice@cozy.cc',
+      instance: instanceUri
+    }, {
+      email: 'bob@cozy.cc',
+      instance: 'https://bob.cozy.cc'
+    }, {
+      email: 'carol@cozy.cc'
+    }];
+    expect(markCurrentUser(recipients, instanceUri).map(function (r) {
+      return r.isCurrentUser;
+    })).toEqual([true, false, false]);
+  });
+  it('does not flag a recipient without instance when the instance is unknown', function () {
+    expect(markCurrentUser([{
+      email: 'carol@cozy.cc'
+    }], undefined)).toEqual([{
+      email: 'carol@cozy.cc',
+      isCurrentUser: false
+    }]);
+  });
+  it('flags the members of group recipients', function () {
+    var recipients = [{
+      name: 'Team',
+      members: [{
+        instance: 'https://bob.cozy.cc'
+      }, {
+        instance: instanceUri
+      }]
+    }];
+
+    var _markCurrentUser = markCurrentUser(recipients, instanceUri),
+        _markCurrentUser2 = _slicedToArray(_markCurrentUser, 1),
+        group = _markCurrentUser2[0];
+
+    expect(group.isCurrentUser).toBe(false);
+    expect(group.members.map(function (m) {
+      return m.isCurrentUser;
+    })).toEqual([false, true]);
+  });
+});
+describe('hasMemberActions', function () {
+  var ownerRights = {
+    isOwner: true,
+    canManageSharing: true,
+    canManageMembers: true
+  };
+  var memberRights = {
+    isOwner: false,
+    canManageSharing: false,
+    canManageMembers: true
+  };
+  it('gives actions on the members to whom can manage the sharing', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, ownerRights), {}, {
+      status: 'ready'
+    }))).toBe(true);
+  });
+  it('gives no action on the owner', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, ownerRights), {}, {
+      status: 'owner'
+    }))).toBe(false);
+  });
+  it('gives no action when the members cannot be managed', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, ownerRights), {}, {
+      canManageMembers: false,
+      status: 'ready'
+    }))).toBe(false);
+  });
+  it('gives actions on themselves to a member who cannot manage the sharing', function () {
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, memberRights), {}, {
+      status: 'ready',
+      isCurrentUser: true
+    }))).toBe(true);
+    expect(hasMemberActions(_objectSpread(_objectSpread({}, memberRights), {}, {
+      status: 'ready'
+    }))).toBe(false);
+  });
+});

package/dist/hooks/useMemberPermissionType.js

@@ -0,0 +1,191 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+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; }
+
+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 { useCallback } from 'react';
+import { useClient } from 'cozy-client';
+import flag from 'cozy-flags';
+import { useFetchDocumentPath } from './useFetchDocumentPath';
+import { useResolveRecipients } from './useResolveRecipients';
+import { useSharingContext } from './useSharingContext';
+import { getSharingDocIds } from '../state';
+/**
+ * Gives what is needed to change the permission type of the members
+ * of a document's sharing
+ *
+ * @param {object} document - Shared document
+ * @param {object} [options]
+ * @param {boolean} [options.shouldFetchPath] - Whether to fetch the document
+ * path, needed to know the shared parent
+ * @returns {{ isInsideSharedParent: boolean, sharedParentName: string|null, setMemberType: Function }}
+ * `setMemberType({ sharingId, memberIndex, type, recipient }, newType, { withAncestors })`
+ * also downgrades the member on the read-write ancestor sharings when `withAncestors` is set
+ */
+
+export var useMemberPermissionType = function useMemberPermissionType(document) {
+  var _sharedParentPath$spl;
+
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      _ref$shouldFetchPath = _ref.shouldFetchPath,
+      shouldFetchPath = _ref$shouldFetchPath === void 0 ? true : _ref$shouldFetchPath;
+
+  var client = useClient();
+
+  var _useSharingContext = useSharingContext(),
+      hasSharedParent = _useSharingContext.hasSharedParent,
+      getSharedParentPath = _useSharingContext.getSharedParentPath,
+      updateSharingMemberType = _useSharingContext.updateSharingMemberType,
+      getSharingById = _useSharingContext.getSharingById,
+      share = _useSharingContext.share;
+
+  var resolveRecipients = useResolveRecipients();
+  var documentPath = useFetchDocumentPath(client, shouldFetchPath ? document : null);
+  var isInsideSharedParent = Boolean(documentPath) && Boolean(hasSharedParent === null || hasSharedParent === void 0 ? void 0 : hasSharedParent(documentPath));
+  var sharedParentPath = documentPath ? getSharedParentPath === null || getSharedParentPath === void 0 ? void 0 : getSharedParentPath(documentPath) : null;
+  var setMemberType = useCallback( /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2, newType) {
+      var sharingId,
+          memberIndex,
+          type,
+          recipient,
+          _ref4,
+          _ref4$withAncestors,
+          withAncestors,
+          ancestors,
+          _iterator,
+          _step,
+          ancestor,
+          documentId,
+          sourceSharing,
+          _yield$resolveRecipie2,
+          recipients,
+          _args = arguments;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            sharingId = _ref2.sharingId, memberIndex = _ref2.memberIndex, type = _ref2.type, recipient = _ref2.recipient;
+            _ref4 = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, _ref4$withAncestors = _ref4.withAncestors, withAncestors = _ref4$withAncestors === void 0 ? false : _ref4$withAncestors;
+
+            if (!withAncestors) {
+              _context.next = 21;
+              break;
+            }
+
+            // Ancestors first: only the target's own update refetches its
+            // effective recipients, which must already see them downgraded.
+            ancestors = ((recipient === null || recipient === void 0 ? void 0 : recipient.sources) || []).filter(function (s) {
+              return s.kind === 'ancestor' && !s.read_only;
+            });
+            _iterator = _createForOfIteratorHelper(ancestors);
+            _context.prev = 5;
+
+            _iterator.s();
+
+          case 7:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 13;
+              break;
+            }
+
+            ancestor = _step.value;
+            _context.next = 11;
+            return updateSharingMemberType(ancestor.sharing_id, ancestor.member_index, newType);
+
+          case 11:
+            _context.next = 7;
+            break;
+
+          case 13:
+            _context.next = 18;
+            break;
+
+          case 15:
+            _context.prev = 15;
+            _context.t0 = _context["catch"](5);
+
+            _iterator.e(_context.t0);
+
+          case 18:
+            _context.prev = 18;
+
+            _iterator.f();
+
+            return _context.finish(18);
+
+          case 21:
+            documentId = (document === null || document === void 0 ? void 0 : document._id) || (document === null || document === void 0 ? void 0 : document.id);
+
+            if (!(flag('drive.federated-shared-folder.enabled') && type === 'one-way' && newType === 'two-way' && documentId)) {
+              _context.next = 34;
+              break;
+            }
+
+            sourceSharing = getSharingById(sharingId);
+
+            if (!(sourceSharing && !getSharingDocIds(sourceSharing).includes(documentId))) {
+              _context.next = 34;
+              break;
+            }
+
+            _context.next = 27;
+            return resolveRecipients([recipient]);
+
+          case 27:
+            _yield$resolveRecipie2 = _context.sent;
+            recipients = _yield$resolveRecipie2.recipients;
+
+            if (recipients[0]) {
+              _context.next = 31;
+              break;
+            }
+
+            throw new Error('Recipient contact not found');
+
+          case 31:
+            _context.next = 33;
+            return share({
+              document: _objectSpread(_objectSpread({}, document), {}, {
+                id: documentId
+              }),
+              description: document.name,
+              recipients: recipients,
+              readOnlyRecipients: [],
+              sharedDrive: true,
+              openSharing: false
+            });
+
+          case 33:
+            return _context.abrupt("return");
+
+          case 34:
+            _context.next = 36;
+            return updateSharingMemberType(sharingId, memberIndex, newType, document);
+
+          case 36:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[5, 15, 18, 21]]);
+    }));
+
+    return function (_x, _x2) {
+      return _ref3.apply(this, arguments);
+    };
+  }(), [document, getSharingById, resolveRecipients, share, updateSharingMemberType]);
+  return {
+    isInsideSharedParent: isInsideSharedParent,
+    sharedParentName: (_sharedParentPath$spl = sharedParentPath === null || sharedParentPath === void 0 ? void 0 : sharedParentPath.split('/').pop()) !== null && _sharedParentPath$spl !== void 0 ? _sharedParentPath$spl : null,
+    setMemberType: setMemberType
+  };
+};