cozy-sharing 5.0.0 → 6.0.0

package/dist/helpers/sharings.js

@@ -11,73 +11,92 @@ export var getSharingObject = function getSharingObject(internalSharing, sharing
     return normalizeDocFromRealtime(sharing, 'io.cozy.sharings');
   }
 };
-export var createSharingInStore = function createSharingInStore(client, doctype, dispatch, docsId, sharing) {
-  // TODO Check if we can getByIds to avoid query in map
-  docsId.map( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(id) {
-      var file, path;
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              if (!(doctype === 'io.cozy.files')) {
-                _context.next = 6;
-                break;
-              }
+export var createSharingInStore = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref) {
+    var client, doctype, dispatch, docsId, sharing;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            client = _ref.client, doctype = _ref.doctype, dispatch = _ref.dispatch, docsId = _ref.docsId, sharing = _ref.sharing;
+            _context2.next = 3;
+            return Promise.all(docsId.map( /*#__PURE__*/function () {
+              var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(id) {
+                var file, path;
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        if (!(doctype === 'io.cozy.files')) {
+                          _context.next = 6;
+                          break;
+                        }
 
-              _context.next = 3;
-              return client.query(Q(doctype).getById(id));
+                        _context.next = 3;
+                        return client.query(Q(doctype).getById(id));
 
-            case 3:
-              _context.t0 = _context.sent;
-              _context.next = 7;
-              break;
+                      case 3:
+                        _context.t0 = _context.sent;
+                        _context.next = 7;
+                        break;
 
-            case 6:
-              _context.t0 = undefined;
+                      case 6:
+                        _context.t0 = undefined;
 
-            case 7:
-              file = _context.t0;
-              _context.t1 = file;
+                      case 7:
+                        file = _context.t0;
+                        _context.t1 = file;
 
-              if (!_context.t1) {
-                _context.next = 16;
-                break;
-              }
+                        if (!_context.t1) {
+                          _context.next = 16;
+                          break;
+                        }
 
-              _context.t2 = file.data.path;
+                        _context.t2 = file.data.path;
 
-              if (_context.t2) {
-                _context.next = 15;
-                break;
-              }
+                        if (_context.t2) {
+                          _context.next = 15;
+                          break;
+                        }
 
-              _context.next = 14;
-              return fetchFilesPaths(client, doctype, [file.data]);
+                        _context.next = 14;
+                        return fetchFilesPaths(client, doctype, [file.data]);
 
-            case 14:
-              _context.t2 = _context.sent;
+                      case 14:
+                        _context.t2 = _context.sent;
 
-            case 15:
-              _context.t1 = _context.t2;
+                      case 15:
+                        _context.t1 = _context.t2;
 
-            case 16:
-              path = _context.t1;
-              dispatch(addSharing(sharing, path));
+                      case 16:
+                        path = _context.t1;
+                        dispatch(addSharing(sharing, path));
 
-            case 18:
-            case "end":
-              return _context.stop();
-          }
+                      case 18:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x2) {
+                return _ref3.apply(this, arguments);
+              };
+            }()));
+
+          case 3:
+          case "end":
+            return _context2.stop();
         }
-      }, _callee);
-    }));
+      }
+    }, _callee2);
+  }));
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }());
-};
+  return function createSharingInStore(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
 export var updateSharingInStore = function updateSharingInStore(dispatch, sharing) {
   dispatch(updateSharing(sharing));
 };

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/index.js

@@ -17,4 +17,5 @@ export { CozyPassFingerprintDialogContent } from './components/CozyPassFingerpri
 export { SharingBannerPlugin } from './SharingBanner';
 export { useSharingInfos } from './SharingBanner/hooks/useSharingInfos';
 export { ConfirmTrustedRecipientsDialog } from './ConfirmTrustedRecipientsDialog';
-export { ShareButtonWithRecipients } from './ShareButtonWithRecipients';
+export { ShareButtonWithRecipients } from './ShareButtonWithRecipients';
+export { DOCUMENT_TYPE } from './helpers/documentType';

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/dist/share.styl

@@ -21,10 +21,6 @@
     .coz-form-group
         flex-shrink 0
 
-    .coz-form-label
-        padding-top 0
-        margin-top  0
-
 .aligned-dropdown-button
   margin-right: -1rem
 
@@ -82,17 +78,6 @@
     .react-select__option:active
         background-color var(--paleGrey) !important
 
-    @media (max-width 32em)
-        .react-select__menu
-            width 100% !important
-
-@media (max-width 32em)
-    .share-type-control
-        flex-direction column
-
-        .select-wrapper
-            margin-bottom .5rem
-
 input[type=text]
     width 100%