cozy-sharing 5.0.0 → 5.0.1

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

@@ -0,0 +1,145 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+var _excluded = ["recipients", "link", "isOwner", "onClick"];
+import React from 'react';
+import { createMockClient } from 'cozy-client';
+import { render } from '@testing-library/react';
+import RecipientsAvatars, { MAX_DISPLAYED_RECIPIENTS, excludeMeAsOwnerFromRecipients } from './RecipientsAvatars';
+import AppLike from '../../../test/AppLike';
+var mockRecipients = new Array(MAX_DISPLAYED_RECIPIENTS - 1).fill({
+  status: 'owner',
+  public_name: 'cozy'
+}, 0, 1).fill({
+  status: 'pending',
+  name: 'Mitch Young'
+}, 1);
+var mockMoreRecipientsThanMaxDisplayed = [].concat(_toConsumableArray(mockRecipients), [{
+  status: 'mail-not-send',
+  name: 'Lyn Webster'
+}, {
+  status: 'ready',
+  name: 'Richelle Young'
+}, {
+  status: 'ready',
+  name: 'John Connor'
+}]);
+describe('RecipientsAvatars', function () {
+  var client = createMockClient({});
+
+  var setup = function setup(_ref) {
+    var _ref$recipients = _ref.recipients,
+        recipients = _ref$recipients === void 0 ? mockRecipients : _ref$recipients,
+        _ref$link = _ref.link,
+        link = _ref$link === void 0 ? false : _ref$link,
+        _ref$isOwner = _ref.isOwner,
+        isOwner = _ref$isOwner === void 0 ? true : _ref$isOwner,
+        _ref$onClick = _ref.onClick,
+        onClick = _ref$onClick === void 0 ? function () {
+      return jest.fn();
+    } : _ref$onClick,
+        rest = _objectWithoutProperties(_ref, _excluded);
+
+    return render( /*#__PURE__*/React.createElement(AppLike, {
+      client: client
+    }, /*#__PURE__*/React.createElement(RecipientsAvatars, _extends({
+      recipients: recipients,
+      onClick: onClick,
+      isOwner: isOwner,
+      link: link
+    }, rest))));
+  };
+
+  it('should render link icon if a link is generated', function () {
+    var _setup = setup({
+      link: true
+    }),
+        getByTestId = _setup.getByTestId;
+
+    expect(getByTestId('recipientsAvatars-link')).toBeTruthy();
+  });
+  it('should not render link icon if a link is not generated', function () {
+    var _setup2 = setup({}),
+        queryByTestId = _setup2.queryByTestId;
+
+    expect(queryByTestId('recipientsAvatars-link')).toBeNull();
+  });
+  it('should hide me as owner by default', function () {
+    var _setup3 = setup({}),
+        queryByTestId = _setup3.queryByTestId;
+
+    expect(queryByTestId('recipientsAvatars-avatar-owner')).toBeNull();
+  });
+  it('should show me as owner if required', function () {
+    var _setup4 = setup({
+      showMeAsOwner: true
+    }),
+        getByTestId = _setup4.getByTestId;
+
+    expect(getByTestId('recipientsAvatars-avatar-owner')).toBeTruthy();
+  });
+  it('should show a +X icon with the correct number if there is more avatars than expected', function () {
+    var _setup5 = setup({
+      recipients: mockMoreRecipientsThanMaxDisplayed,
+      showMeAsOwner: true
+    }),
+        getByTestId = _setup5.getByTestId,
+        getByText = _setup5.getByText;
+
+    var delta = mockMoreRecipientsThanMaxDisplayed.length - MAX_DISPLAYED_RECIPIENTS;
+    expect(getByTestId('recipientsAvatars-plusX')).toBeTruthy();
+    expect(getByText("+".concat(delta))).toBeTruthy();
+  });
+  it('should show both +X and link icon if necessary', function () {
+    var _setup6 = setup({
+      recipients: mockMoreRecipientsThanMaxDisplayed,
+      showMeAsOwner: true,
+      link: true
+    }),
+        getByTestId = _setup6.getByTestId;
+
+    expect(getByTestId('recipientsAvatars-plusX')).toBeTruthy();
+    expect(getByTestId('recipientsAvatars-link')).toBeTruthy();
+  });
+});
+describe('excludeMeAsOwnerFromRecipients', function () {
+  test('excludeMeAsOwnerFromRecipients behavior', function () {
+    var recipients = [{
+      status: 'owner',
+      instance: 'http://foo1.cozy.bar'
+    }, {
+      status: 'pending',
+      instance: 'http://foo2.cozy.bar'
+    }, {
+      status: 'pending',
+      instance: 'http://foo3.cozy.bar'
+    }];
+    var client = {
+      options: {
+        uri: 'http://foo2.cozy.bar'
+      }
+    };
+    expect(excludeMeAsOwnerFromRecipients({
+      recipients: recipients,
+      isOwner: true,
+      client: client
+    })).toEqual([{
+      status: 'pending',
+      instance: 'http://foo2.cozy.bar'
+    }, {
+      status: 'pending',
+      instance: 'http://foo3.cozy.bar'
+    }]);
+    expect(excludeMeAsOwnerFromRecipients({
+      recipients: recipients,
+      isOwner: false,
+      client: client
+    })).toEqual([{
+      status: 'owner',
+      instance: 'http://foo1.cozy.bar'
+    }, {
+      status: 'pending',
+      instance: 'http://foo3.cozy.bar'
+    }]);
+  });
+});

package/dist/components/Recipient/recipient.styl

@@ -0,0 +1,82 @@
+@require 'components/button.styl'
+@require 'settings/breakpoints.styl'
+@require 'settings/palette.styl'
+
+:root
+  --genericRecipientBackground: var(--slateGrey)
+  --genericRecipientColor: var(--white)
+
+.recipient
+    display flex
+    flex-direction row
+    align-items center
+
+    +small-screen()
+        align-items flex-start
+
+.recipients-list-light
+    .recipient
+        margin 1rem 0
+
+    & + .recipient
+        margin-top 1rem
+
+.recipient-idents
+    flex 1 1 auto
+    overflow hidden
+    text-overflow ellipsis
+
+.recipient-status-icon
+  margin-right: .25rem
+
+.recipient-user
+.recipient-details
+    text-overflow ellipsis
+    overflow hidden
+    white-space nowrap
+    line-height 1.3
+
+.recipient-user
+    font-size 1rem
+    font-weight bold
+
+.recipient-details
+    font-size .875rem
+    color var(--coolGrey)
+
+.avatar
+    display flex
+    flex-direction row
+    align-items center
+
+    .recipient-user
+        font-size 1.125rem
+
+.link-recipient-icon-circle
+    border 1px solid var(--borderMainColor)
+    background-color unset
+    color unset
+
+.recipients-avatars
+    display inline-flex
+    flex-direction row-reverse
+    margin-right 0.5rem
+
+    &.--interactive
+        cursor pointer
+
+    &--link,
+    &--plusX,
+    &--avatar
+        border-width 2px
+        border-style solid
+        border-color var(--white)
+
+    &--link
+        background-color var(--genericRecipientBackground)
+        svg
+            fill: var(--genericRecipientColor)
+
+    &--plusX,
+    &--avatar
+        margin-right -0.6rem

package/dist/components/ShareButtonWithRecipients.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import ShareButton from '../ShareButton';
+
+var ShareButtonWithRecipients = function ShareButtonWithRecipients(props) {
+  return /*#__PURE__*/React.createElement(ShareButton, props);
+};
+
+export default ShareButtonWithRecipients;

package/dist/helpers/documentType.js

@@ -0,0 +1,6 @@
+export var DOCUMENT_TYPE = {
+  ALBUMS: 'Albums',
+  FILES: 'Files',
+  NOTES: 'Notes',
+  ORGANIZATIONS: 'Organizations'
+};

package/dist/helpers/link.js

@@ -0,0 +1,5 @@
+import { DOCUMENT_TYPE } from './documentType';
+export var isOnlyReadOnlyLinkAllowed = function isOnlyReadOnlyLinkAllowed(_ref) {
+  var documentType = _ref.documentType;
+  return documentType === DOCUMENT_TYPE.ALBUMS;
+};

package/dist/helpers/permissions.js

@@ -0,0 +1,8 @@
+import get from 'lodash/get';
+import { models } from 'cozy-client';
+export var checkIsReadOnlyPermissions = function checkIsReadOnlyPermissions(permissions) {
+  var permissionCategories = get(permissions, '[0].attributes.permissions', {});
+  return Object.values(permissionCategories).filter(function (permissionCategory) {
+    return models.permission.isReadOnly(permissionCategory);
+  }).length > 0;
+};

package/dist/helpers/recipients.js

@@ -0,0 +1,24 @@
+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; }
+
+export var filterAndReworkRecipients = function filterAndReworkRecipients(recipients, previousRecipients) {
+  return recipients.filter(function (recipient) {
+    return recipient.status !== 'owner';
+  }).map(function (recipient) {
+    var recipientHasChanged = previousRecipients && !previousRecipients.find(function (previousRecipient) {
+      return previousRecipient.name === recipient.name && previousRecipient.email === recipient.email;
+    });
+
+    if (recipientHasChanged) {
+      return _objectSpread(_objectSpread({}, recipient), {}, {
+        hasBeenJustAdded: true
+      });
+    }
+
+    return recipient;
+  });
+};
+export var FADE_IN_DURATION = 600;

package/dist/helpers/synchronousJobQueue.js

@@ -0,0 +1,67 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var SynchronousJobQueue = /*#__PURE__*/function () {
+  function SynchronousJobQueue() {
+    _classCallCheck(this, SynchronousJobQueue);
+
+    this.isRunning = false;
+    this.queue = [];
+  }
+
+  _createClass(SynchronousJobQueue, [{
+    key: "push",
+    value: function push(job) {
+      this.queue.push(job);
+
+      if (!this.isRunning) {
+        this.run();
+      }
+    }
+  }, {
+    key: "run",
+    value: function () {
+      var _run = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var job;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                this.isRunning = true;
+
+              case 1:
+                if (!(this.queue.length > 0)) {
+                  _context.next = 7;
+                  break;
+                }
+
+                job = this.queue.shift();
+                _context.next = 5;
+                return job.function(job.arguments);
+
+              case 5:
+                _context.next = 1;
+                break;
+
+              case 7:
+                this.isRunning = false;
+
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function run() {
+        return _run.apply(this, arguments);
+      }
+
+      return run;
+    }()
+  }]);
+
+  return SynchronousJobQueue;
+}();

package/dist/helpers/synchronousJobQueue.spec.js

@@ -0,0 +1,97 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { SynchronousJobQueue } from './synchronousJobQueue';
+
+var flushPromises = function flushPromises() {
+  return new Promise(process.nextTick);
+};
+
+var callback = jest.fn();
+var resolveAfter100Ms = jest.fn().mockImplementation(function () {
+  callback('100Ms start');
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      callback('100Ms end');
+      resolve();
+    }, 100);
+  });
+});
+var resolveAfter500Ms = jest.fn().mockImplementation(function () {
+  callback('500Ms start');
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      callback('500Ms end');
+      resolve();
+    }, 500);
+  });
+});
+describe('SynchronousJobQueue', function () {
+  beforeEach(function () {
+    jest.useFakeTimers();
+  });
+  afterEach(function () {
+    jest.useRealTimers();
+    jest.clearAllMocks();
+  });
+  it('should execute job synchronously with SynchronousJobQueue', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var synchronousJobQueue, expectedCallbackOrder;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            synchronousJobQueue = new SynchronousJobQueue();
+            synchronousJobQueue.push({
+              function: resolveAfter500Ms
+            });
+            synchronousJobQueue.push({
+              function: resolveAfter100Ms
+            });
+            jest.runAllTimers();
+            _context.next = 6;
+            return flushPromises();
+
+          case 6:
+            jest.runAllTimers();
+            _context.next = 9;
+            return flushPromises();
+
+          case 9:
+            expectedCallbackOrder = [['500Ms start'], ['500Ms end'], ['100Ms start'], ['100Ms end']];
+            expect(callback.mock.calls).toEqual(expectedCallbackOrder);
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+  it('should execute job asynchronously without SynchronousJobQueue', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var expectedCallbackOrder;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            resolveAfter500Ms();
+            resolveAfter100Ms();
+            jest.runAllTimers();
+            _context2.next = 5;
+            return flushPromises();
+
+          case 5:
+            jest.runAllTimers();
+            _context2.next = 8;
+            return flushPromises();
+
+          case 8:
+            expectedCallbackOrder = [['500Ms start'], ['100Ms start'], ['100Ms end'], ['500Ms end']];
+            expect(callback.mock.calls).toEqual(expectedCallbackOrder);
+
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  })));
+});

package/dist/queries/queries.js

@@ -0,0 +1,72 @@
+import { Q, fetchPolicies } from 'cozy-client';
+import { Contact, Group } from '../models';
+var DEFAULT_CACHE_TIMEOUT_QUERIES = 9 * 60 * 1000;
+var defaultFetchPolicy = fetchPolicies.olderThan(DEFAULT_CACHE_TIMEOUT_QUERIES);
+export var fetchApps = function fetchApps() {
+  return {
+    definition: Q('io.cozy.apps'),
+    options: {
+      as: 'io.cozy.apps',
+      fetchPolicy: defaultFetchPolicy
+    }
+  };
+};
+export var buildSharingsByIdQuery = function buildSharingsByIdQuery(sharingId) {
+  return {
+    definition: Q('io.cozy.sharings').getById(sharingId),
+    options: {
+      as: "io.cozy.sharings/".concat(sharingId),
+      fetchPolicy: defaultFetchPolicy
+    }
+  };
+};
+export var buildContactsQuery = function buildContactsQuery() {
+  return {
+    definition: Q(Contact.doctype).where({
+      _id: {
+        $gt: null
+      }
+    }).partialIndex({
+      trashed: {
+        $or: [{
+          $eq: false
+        }, {
+          $exists: false
+        }]
+      },
+      $or: [{
+        cozy: {
+          $not: {
+            $size: 0
+          }
+        }
+      }, {
+        email: {
+          $not: {
+            $size: 0
+          }
+        }
+      }]
+    }).indexFields(['_id']).limitBy(1000),
+    options: {
+      as: 'io.cozy.contacts'
+    }
+  };
+};
+export var buildGroupsQuery = function buildGroupsQuery() {
+  return {
+    definition: Q(Group.doctype),
+    options: {
+      as: 'io.cozy.contacts.groups'
+    }
+  };
+};
+export var buildInstanceSettingsQuery = function buildInstanceSettingsQuery() {
+  return {
+    definition: Q('io.cozy.settings').getById('instance'),
+    options: {
+      as: 'io.cozy.settings/instance',
+      singleDocData: true
+    }
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -60,6 +60,5 @@
   },
   "sideEffects": [
     "*.css"
-  ],
-  "gitHead": "621683a1fd3dfe4abc029f5c3238c164acb5aec0"
+  ]
 }

package/src/SharingBanner/hooks/useSharingInfos.jsx

@@ -12,7 +12,7 @@ const getSharingId = permission => {
   return sharingId
 }
 
-export const useSharingInfos = () => {
+export const useSharingInfos = (previewPath = '/preview') => {
   const client = useClient()
 
   const [discoveryLink, setDiscoveryLink] = useState()
@@ -52,12 +52,12 @@ export const useSharingInfos = () => {
       }
     }
 
-    if (window.location.pathname === '/preview') {
+    if (window.location.pathname === previewPath) {
       loadSharingDiscoveryLink()
     } else {
       setLoading(false)
     }
-  }, [client])
+  }, [client, previewPath])
 
   return {
     sharing,

package/src/SharingBanner/index.jsx

@@ -1,13 +1,17 @@
 import React from 'react'
+import PropTypes from 'prop-types'
 
 import withLocales from '../withLocales'
 import { useSharingInfos } from './hooks/useSharingInfos'
 import { SharingBanner } from './components/SharingBanner'
 
-const Plugin = () => {
-  const sharingInfos = useSharingInfos()
-
+const Plugin = ({ previewPath }) => {
+  const sharingInfos = useSharingInfos(previewPath)
   return <SharingBanner sharingInfos={sharingInfos} />
 }
 
+Plugin.propTypes = {
+  previewPath: PropTypes.string
+}
+
 export const SharingBannerPlugin = withLocales(Plugin)

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Cozy.io
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.