cozy-sharing 30.2.0 → 30.2.2

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [30.2.2](https://github.com/cozy/cozy-libs/compare/cozy-sharing@30.2.1...cozy-sharing@30.2.2) (2026-04-22)
+
+**Note:** Version bump only for package cozy-sharing
+
+## [30.2.1](https://github.com/cozy/cozy-libs/compare/cozy-sharing@30.2.0...cozy-sharing@30.2.1) (2026-04-20)
+
+### Bug Fixes
+
+- **cozy-sharing:** Preserve user gesture for Safari clipboard writes ([c3e9069](https://github.com/cozy/cozy-libs/commit/c3e9069e250880b9d6640c8ae7529b987af497dc))
+
 # [30.2.0](https://github.com/cozy/cozy-libs/compare/cozy-sharing@30.1.1...cozy-sharing@30.2.0) (2026-04-20)
 
 ### Features

package/dist/components/ShareByLink.js

@@ -118,48 +118,55 @@ var ShareByLink = function ShareByLink(_ref) {
 
   var generateLinkAndCopyLinkToClipboard = /*#__PURE__*/function () {
     var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-      var linkToCopy, wasNewlyGenerated;
+      var generatedLink;
       return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
-            linkToCopy = link;
-            wasNewlyGenerated = !linkToCopy;
-
-            if (linkToCopy) {
-              _context2.next = 6;
+            if (!link) {
+              _context2.next = 4;
               break;
             }
 
-            _context2.next = 5;
-            return handleGenerateLink();
-
-          case 5:
-            linkToCopy = _context2.sent;
+            _context2.next = 3;
+            return copyToClipboard(link, {
+              t: t,
+              showAlert: showAlert
+            });
 
-          case 6:
-            if (!linkToCopy) {
-              _context2.next = 12;
-              break;
-            }
+          case 3:
+            return _context2.abrupt("return");
 
-            _context2.next = 9;
-            return copyToClipboard(linkToCopy, {
+          case 4:
+            // Safari: the clipboard API must be invoked synchronously within the
+            // click handler, so we pass the pending link to `copyToClipboard`.
+            // The resolved URL is captured here so we can branch on success after
+            // the copy has completed, without re-awaiting the promise.
+            generatedLink = null;
+            _context2.next = 7;
+            return copyToClipboard(handleGenerateLink().then(function (generated) {
+              generatedLink = generated;
+              if (!generated) throw new Error('link-generation-failed');
+              return generated;
+            }), {
               t: t,
               showAlert: showAlert
             });
 
-          case 9:
-            if (wasNewlyGenerated && autoOpenShareRestriction) {
-              toggleEditDialogOpen();
+          case 7:
+            if (generatedLink) {
+              _context2.next = 10;
+              break;
             }
 
-            _context2.next = 13;
-            break;
-
-          case 12:
             showGenericError();
+            return _context2.abrupt("return");
 
-          case 13:
+          case 10:
+            if (autoOpenShareRestriction) {
+              toggleEditDialogOpen();
+            }
+
+          case 11:
           case "end":
             return _context2.stop();
         }

package/dist/components/ShareRestrictionModal/ShareRestrictionModal.js

@@ -91,96 +91,83 @@ export var ShareRestrictionModal = function ShareRestrictionModal(_ref) {
 
   var handleClick = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var ttl, _yield$createPermissi2, perms, url, _yield$updatePermissi3, _yield$updatePermissi4, _perms, _url;
-
+      var permsPromise, urlPromise;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            setLoading(true); // If the file is not shared, we create a new sharing link
-
-            if (hasSharingLink) {
-              _context.next = 13;
-              break;
-            }
+            setLoading(true); // The clipboard write must be initiated synchronously within the click
+            // handler for Safari to honor the user gesture; we pass a pending blob
+            // whose content resolves after the permission round-trip.
 
-            ttl = makeTTL(dateToggle && selectedDate);
-            _context.next = 5;
-            return createPermissions({
+            permsPromise = hasSharingLink ? updatePermissions({
               file: file,
               t: t,
-              ttl: ttl,
+              dateToggle: dateToggle,
+              selectedDate: selectedDate,
+              passwordToggle: passwordToggle,
               password: password,
               editingRights: editingRights,
               documentType: documentType,
-              shareByLink: shareByLink,
-              showAlert: showAlert
-            });
-
-          case 5:
-            _yield$createPermissi2 = _context.sent;
-            perms = _yield$createPermissi2.data;
-            url = generateWebLink({
-              cozyUrl: client.getStackClient().uri,
-              searchParams: [['sharecode', perms.attributes.shortcodes.code]],
-              pathname: '/public',
-              slug: getAppSlugFromDocumentType({
-                documentType: documentType
-              }),
-              subDomainType: client.capabilities.flat_subdomains ? 'flat' : 'nested'
-            });
-            _context.next = 10;
-            return copyToClipboard(url, {
-              t: t,
+              updateDocumentPermissions: updateDocumentPermissions,
               showAlert: showAlert
-            });
-
-          case 10:
-            onClose();
-            _context.next = 22;
-            break;
+            }).then(function (_ref3) {
+              var _ref4 = _slicedToArray(_ref3, 1),
+                  perms = _ref4[0].data;
 
-          case 13:
-            _context.next = 15;
-            return updatePermissions({
+              return perms;
+            }) : createPermissions({
               file: file,
               t: t,
-              dateToggle: dateToggle,
-              selectedDate: selectedDate,
-              passwordToggle: passwordToggle,
+              ttl: makeTTL(dateToggle && selectedDate),
               password: password,
               editingRights: editingRights,
               documentType: documentType,
-              updateDocumentPermissions: updateDocumentPermissions,
+              shareByLink: shareByLink,
               showAlert: showAlert
+            }).then(function (_ref5) {
+              var perms = _ref5.data;
+              return perms;
             });
-
-          case 15:
-            _yield$updatePermissi3 = _context.sent;
-            _yield$updatePermissi4 = _slicedToArray(_yield$updatePermissi3, 1);
-            _perms = _yield$updatePermissi4[0].data;
-            _url = generateWebLink({
-              cozyUrl: client.getStackClient().uri,
-              searchParams: [['sharecode', _perms.attributes.shortcodes.code]],
-              pathname: '/public',
-              slug: getAppSlugFromDocumentType({
-                documentType: documentType
-              }),
-              subDomainType: client.capabilities.flat_subdomains ? 'flat' : 'nested'
+            urlPromise = permsPromise.then(function (perms) {
+              return generateWebLink({
+                cozyUrl: client.getStackClient().uri,
+                searchParams: [['sharecode', perms.attributes.shortcodes.code]],
+                pathname: '/public',
+                slug: getAppSlugFromDocumentType({
+                  documentType: documentType
+                }),
+                subDomainType: client.capabilities.flat_subdomains ? 'flat' : 'nested'
+              });
             });
-            _context.next = 21;
-            return copyToClipboard(_url, {
+            _context.next = 5;
+            return copyToClipboard(urlPromise, {
               t: t,
               showAlert: showAlert
             });
 
-          case 21:
+          case 5:
+            _context.prev = 5;
+            _context.next = 8;
+            return permsPromise;
+
+          case 8:
+            _context.next = 14;
+            break;
+
+          case 10:
+            _context.prev = 10;
+            _context.t0 = _context["catch"](5);
+            setLoading(false);
+            return _context.abrupt("return");
+
+          case 14:
             onClose();
 
-          case 22:
+          case 15:
           case "end":
             return _context.stop();
         }
-      }, _callee);
+      }, _callee, null, [[5, 10]]);
     }));
 
     return function handleClick() {
@@ -189,7 +176,7 @@ export var ShareRestrictionModal = function ShareRestrictionModal(_ref) {
   }();
 
   var handleRevokeLink = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
       return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
@@ -214,7 +201,7 @@ export var ShareRestrictionModal = function ShareRestrictionModal(_ref) {
     }));
 
     return function handleRevokeLink() {
-      return _ref3.apply(this, arguments);
+      return _ref6.apply(this, arguments);
     };
   }();
 

package/dist/components/ShareRestrictionModal/helpers.js

@@ -115,11 +115,19 @@ export var generateShareLinkFromFile = function generateShareLinkFromFile(_ref3)
   });
 };
 /**
- * Copy a string to the clipboard
+ * Copy a value to the clipboard.
  *
- * @param {string} value - The string saved to the clipboard
+ * Accepts a resolved string or a `Promise<string>`. The promise form is
+ * required when the value depends on a prior async step (e.g. creating a
+ * sharing link) from within a click handler: Safari drops the user-gesture
+ * context across any `await`, so `navigator.clipboard.writeText` called after
+ * an awaited call throws `NotAllowedError`. Passing a pending blob to
+ * `ClipboardItem` lets the clipboard API be invoked synchronously while the
+ * content is resolved later.
+ *
+ * @param {string | Promise<string>} value - Value to copy
  * @param {object} [options]
- * @param {number} options.t - Translation function
+ * @param {Function} options.t - Translation function
  * @param {Function} options.showAlert - Function to display an alert
  */
 
@@ -128,6 +136,7 @@ export var copyToClipboard = /*#__PURE__*/function () {
     var _ref5,
         t,
         showAlert,
+        blobPromise,
         _args2 = arguments;
 
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
@@ -144,33 +153,73 @@ export var copyToClipboard = /*#__PURE__*/function () {
 
         case 3:
           _context2.prev = 3;
-          _context2.next = 6;
+
+          if (!(typeof value === 'string')) {
+            _context2.next = 9;
+            break;
+          }
+
+          _context2.next = 7;
           return navigator.clipboard.writeText(value);
 
-        case 6:
+        case 7:
+          _context2.next = 21;
+          break;
+
+        case 9:
+          if (!(typeof ClipboardItem !== 'undefined')) {
+            _context2.next = 15;
+            break;
+          }
+
+          blobPromise = Promise.resolve(value).then(function (text) {
+            return new Blob([text], {
+              type: 'text/plain'
+            });
+          });
+          _context2.next = 13;
+          return navigator.clipboard.write([new ClipboardItem({
+            'text/plain': blobPromise
+          })]);
+
+        case 13:
+          _context2.next = 21;
+          break;
+
+        case 15:
+          _context2.t0 = navigator.clipboard;
+          _context2.next = 18;
+          return value;
+
+        case 18:
+          _context2.t1 = _context2.sent;
+          _context2.next = 21;
+          return _context2.t0.writeText.call(_context2.t0, _context2.t1);
+
+        case 21:
           showAlert({
             message: t('copyReminderContent.success'),
             severity: 'success',
             variant: 'filled'
           });
-          _context2.next = 13;
+          _context2.next = 28;
           break;
 
-        case 9:
-          _context2.prev = 9;
-          _context2.t0 = _context2["catch"](3);
+        case 24:
+          _context2.prev = 24;
+          _context2.t2 = _context2["catch"](3);
           showAlert({
             message: t('copyReminderContent.error'),
             severity: 'error',
             variant: 'filled'
           });
-          log.error("Error in 'copyToClipboard' function when trying to copy to clipboard", _context2.t0);
+          log.error("Error in 'copyToClipboard' function when trying to copy to clipboard", _context2.t2);
 
-        case 13:
+        case 28:
         case "end":
           return _context2.stop();
       }
-    }, _callee2, null, [[3, 9]]);
+    }, _callee2, null, [[3, 24]]);
   }));
 
   return function copyToClipboard(_x2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "30.2.0",
+  "version": "30.2.2",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -59,7 +59,7 @@
     "cozy-intent": "^2.31.1",
     "cozy-minilog": "^3.10.1",
     "cozy-ui": "^138.1.0",
-    "cozy-ui-plus": "^7.0.0",
+    "cozy-ui-plus": "^7.1.0",
     "jest": "30.3.0",
     "jest-environment-jsdom": "30.3.0",
     "react": "16.12.0",
@@ -84,5 +84,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "b8142134f35abde2f7c32aa2109f5f5b111505c9"
+  "gitHead": "54d377d08003a9d2eb2bd96f9eeb87d27637d841"
 }

package/src/components/ShareByLink.jsx

@@ -75,18 +75,29 @@ const ShareByLink = ({
   }
 
   const generateLinkAndCopyLinkToClipboard = async () => {
-    let linkToCopy = link
-    const wasNewlyGenerated = !linkToCopy
-    if (!linkToCopy) {
-      linkToCopy = await handleGenerateLink()
+    if (link) {
+      await copyToClipboard(link, { t, showAlert })
+      return
     }
-    if (linkToCopy) {
-      await copyToClipboard(linkToCopy, { t, showAlert })
-      if (wasNewlyGenerated && autoOpenShareRestriction) {
-        toggleEditDialogOpen()
-      }
-    } else {
+    // Safari: the clipboard API must be invoked synchronously within the
+    // click handler, so we pass the pending link to `copyToClipboard`.
+    // The resolved URL is captured here so we can branch on success after
+    // the copy has completed, without re-awaiting the promise.
+    let generatedLink = null
+    await copyToClipboard(
+      handleGenerateLink().then(generated => {
+        generatedLink = generated
+        if (!generated) throw new Error('link-generation-failed')
+        return generated
+      }),
+      { t, showAlert }
+    )
+    if (!generatedLink) {
       showGenericError()
+      return
+    }
+    if (autoOpenShareRestriction) {
+      toggleEditDialogOpen()
     }
   }
 

package/src/components/ShareRestrictionModal/ShareRestrictionModal.jsx

@@ -77,51 +77,55 @@ export const ShareRestrictionModal = ({ file, onClose }) => {
 
   const handleClick = async () => {
     setLoading(true)
-    // If the file is not shared, we create a new sharing link
-    if (!hasSharingLink) {
-      const ttl = makeTTL(dateToggle && selectedDate)
-      const { data: perms } = await createPermissions({
-        file,
-        t,
-        ttl,
-        password,
-        editingRights,
-        documentType,
-        shareByLink,
-        showAlert
-      })
-      const url = generateWebLink({
-        cozyUrl: client.getStackClient().uri,
-        searchParams: [['sharecode', perms.attributes.shortcodes.code]],
-        pathname: '/public',
-        slug: getAppSlugFromDocumentType({ documentType }),
-        subDomainType: client.capabilities.flat_subdomains ? 'flat' : 'nested'
-      })
-      await copyToClipboard(url, { t, showAlert })
-      onClose()
-    } else {
-      const [{ data: perms }] = await updatePermissions({
-        file,
-        t,
-        dateToggle,
-        selectedDate,
-        passwordToggle,
-        password,
-        editingRights,
-        documentType,
-        updateDocumentPermissions,
-        showAlert
-      })
-      const url = generateWebLink({
+    // The clipboard write must be initiated synchronously within the click
+    // handler for Safari to honor the user gesture; we pass a pending blob
+    // whose content resolves after the permission round-trip.
+    const permsPromise = hasSharingLink
+      ? updatePermissions({
+          file,
+          t,
+          dateToggle,
+          selectedDate,
+          passwordToggle,
+          password,
+          editingRights,
+          documentType,
+          updateDocumentPermissions,
+          showAlert
+        }).then(([{ data: perms }]) => perms)
+      : createPermissions({
+          file,
+          t,
+          ttl: makeTTL(dateToggle && selectedDate),
+          password,
+          editingRights,
+          documentType,
+          shareByLink,
+          showAlert
+        }).then(({ data: perms }) => perms)
+
+    const urlPromise = permsPromise.then(perms =>
+      generateWebLink({
         cozyUrl: client.getStackClient().uri,
         searchParams: [['sharecode', perms.attributes.shortcodes.code]],
         pathname: '/public',
         slug: getAppSlugFromDocumentType({ documentType }),
         subDomainType: client.capabilities.flat_subdomains ? 'flat' : 'nested'
       })
-      await copyToClipboard(url, { t, showAlert })
-      onClose()
+    )
+
+    await copyToClipboard(urlPromise, { t, showAlert })
+    try {
+      // Observe the permission result so we can keep the modal open (and
+      // preserve the user's date / password / editing-rights inputs) if
+      // the permission round-trip failed. copyToClipboard swallows its
+      // own errors so the await above always resolves.
+      await permsPromise
+    } catch {
+      setLoading(false)
+      return
     }
+    onClose()
   }
 
   const handleRevokeLink = async () => {

package/src/components/ShareRestrictionModal/helpers.js

@@ -96,17 +96,36 @@ export const generateShareLinkFromFile = ({
 }
 
 /**
- * Copy a string to the clipboard
+ * Copy a value to the clipboard.
  *
- * @param {string} value - The string saved to the clipboard
+ * Accepts a resolved string or a `Promise<string>`. The promise form is
+ * required when the value depends on a prior async step (e.g. creating a
+ * sharing link) from within a click handler: Safari drops the user-gesture
+ * context across any `await`, so `navigator.clipboard.writeText` called after
+ * an awaited call throws `NotAllowedError`. Passing a pending blob to
+ * `ClipboardItem` lets the clipboard API be invoked synchronously while the
+ * content is resolved later.
+ *
+ * @param {string | Promise<string>} value - Value to copy
  * @param {object} [options]
- * @param {number} options.t - Translation function
+ * @param {Function} options.t - Translation function
  * @param {Function} options.showAlert - Function to display an alert
  */
 export const copyToClipboard = async (value, { t, showAlert } = {}) => {
   if (!value) return false
   try {
-    await navigator.clipboard.writeText(value)
+    if (typeof value === 'string') {
+      await navigator.clipboard.writeText(value)
+    } else if (typeof ClipboardItem !== 'undefined') {
+      const blobPromise = Promise.resolve(value).then(
+        text => new Blob([text], { type: 'text/plain' })
+      )
+      await navigator.clipboard.write([
+        new ClipboardItem({ 'text/plain': blobPromise })
+      ])
+    } else {
+      await navigator.clipboard.writeText(await value)
+    }
     showAlert({
       message: t('copyReminderContent.success'),
       severity: 'success',