@atlaskit/smart-card 25.4.1 → 25.4.2

package/dist/es2019/state/actions/index.js

@@ -1,19 +1,16 @@
 import { useMemo, useCallback } from 'react';
 import { auth } from '@atlaskit/outbound-auth-flow-client';
 import { useSmartLinkContext } from '@atlaskit/link-provider';
-import { ACTION_RESOLVED, ACTION_ERROR, ACTION_ERROR_FALLBACK, ACTION_RELOADING, ACTION_UPDATE_METADATA_STATUS, cardAction, APIError, ACTION_RESOLVING } from '@atlaskit/linking-common';
-import { getDefinitionId, getByDefinitionId, getServices, getStatus, getExtensionKey } from '../helpers';
-import { ERROR_MESSAGE_OAUTH, ERROR_MESSAGE_FATAL, ERROR_MESSAGE_METADATA } from './constants';
+import { ACTION_UPDATE_METADATA_STATUS, cardAction, ACTION_RESOLVING } from '@atlaskit/linking-common';
+import { getDefinitionId, getByDefinitionId, getServices, getExtensionKey } from '../helpers';
 import * as measure from '../../utils/performance';
-import { getUnauthorizedJsonLd } from '../../utils/jsonld';
-import { addMetadataToExperience } from '../analytics';
 import { SmartLinkStatus } from '../../constants';
-import { extractLozengeText } from '../../extractors/common/lozenge/extractLozengeText';
+import useResolve from '../hooks/use-resolve';
 export const useSmartCardActions = (id, url, analytics) => {
+  const resolveUrl = useResolve();
   const {
     store,
-    connections,
-    config
+    connections
   } = useSmartLinkContext();
   const {
     getState,
@@ -27,103 +24,12 @@ export const useSmartCardActions = (id, url, analytics) => {
     status: SmartLinkStatus.Pending,
     details: undefined
   };
-  const hasAuthFlowSupported = config.authFlow !== 'disabled';
-  const hasData = !!(details && details.data);
   const setMetadataStatus = useCallback(metadataStatus => {
     dispatch(cardAction(ACTION_UPDATE_METADATA_STATUS, {
       url
     }, undefined, undefined, metadataStatus));
   }, [dispatch, url]);
-  const handleResolvedLinkError = useCallback((url, error, response, isMetadataRequest) => {
-    // If metadata request then set metadata status, return and do not alter link status
-    if (isMetadataRequest) {
-      setMetadataStatus('errored');
-      return;
-    }
-    if (error.kind === 'fatal') {
-      // If there's no previous data in the store for this URL, then bail
-      // out and let the editor handle fallbacks (returns to a blue link).
-      if (!hasData && status !== 'resolved') {
-        dispatch(cardAction(ACTION_ERROR, {
-          url
-        }, details, error));
-        throw error;
-      }
-      // If we already have resolved data for this URL in the store, then
-      // simply fallback to the previous data.
-      if (hasData) {
-        dispatch(cardAction(ACTION_RESOLVED, {
-          url
-        }, details));
-      }
-      // Handle AuthErrors (user did not have access to resource) -
-      // Missing AAID in ASAP claims, or missing UserContext, or 403 from downstream
-    } else if (error.kind === 'auth') {
-      dispatch(cardAction(ACTION_RESOLVED, {
-        url
-      }, getUnauthorizedJsonLd()));
-    } else {
-      if (error.kind === 'fallback') {
-        // Fallback to blue link with smart link formatting. Not part of reliability.
-        dispatch(cardAction(ACTION_ERROR_FALLBACK, {
-          url
-        }, response, error));
-      } else {
-        // Fallback to blue link with smart link formatting. Part of reliability.
-        dispatch(cardAction(ACTION_ERROR, {
-          url
-        }, undefined, error));
-      }
-    }
-  }, [setMetadataStatus, hasData, status, dispatch, details]);
-  const handleResolvedLinkResponse = useCallback((resourceUrl, response, isReloading = false, isMetadataRequest) => {
-    const hostname = new URL(resourceUrl).hostname;
-    const nextStatus = response ? getStatus(response) : 'fatal';
-
-    // If we require authorization & do not have an authFlow available,
-    // throw an error and render as a normal blue link.
-    if ((nextStatus === 'unauthorized' || nextStatus === 'forbidden') && !hasAuthFlowSupported) {
-      handleResolvedLinkError(resourceUrl, new APIError('fallback', hostname, ERROR_MESSAGE_OAUTH), response, isMetadataRequest);
-      return;
-    }
-
-    // Handle any other errors
-    if (nextStatus === 'fatal') {
-      handleResolvedLinkError(resourceUrl, new APIError('fatal', hostname, ERROR_MESSAGE_FATAL), undefined, isMetadataRequest);
-      return;
-    }
-
-    // Handle errors of any other kind in the metadata request response
-    if (isMetadataRequest && nextStatus !== 'resolved') {
-      handleResolvedLinkError(resourceUrl, new APIError('error', hostname, ERROR_MESSAGE_METADATA), response, isMetadataRequest);
-      return;
-    }
-
-    //if a link resolves normally, metadata will also always be resolved
-    setMetadataStatus('resolved');
-    // Dispatch Analytics and resolved card action - including unauthorized states.
-    if (isReloading) {
-      dispatch(cardAction(ACTION_RELOADING, {
-        url: resourceUrl
-      }, response));
-    } else {
-      dispatch(cardAction(ACTION_RESOLVED, {
-        url: resourceUrl
-      }, response, undefined, undefined, isMetadataRequest));
-    }
-  }, [dispatch, handleResolvedLinkError, hasAuthFlowSupported, setMetadataStatus]);
-  const resolve = useCallback(async (resourceUrl = url, isReloading = false, isMetadataRequest = false) => {
-    // Request JSON-LD data for the card from ORS, if it has extended
-    // its cache lifespan OR there is no data for it currently. Once the data
-    // has come back asynchronously, dispatch the resolved action for the card.
-    if (isReloading || !hasData || isMetadataRequest) {
-      return connections.client.fetchData(resourceUrl, isReloading).then(response => handleResolvedLinkResponse(resourceUrl, response, isReloading, isMetadataRequest)).catch(error => handleResolvedLinkError(resourceUrl, error, undefined, isMetadataRequest));
-    } else {
-      addMetadataToExperience('smart-link-rendered', id, {
-        cached: true
-      });
-    }
-  }, [url, hasData, connections.client, handleResolvedLinkResponse, handleResolvedLinkError, id]);
+  const resolve = useCallback(async (resourceUrl = url, isReloading = false, isMetadataRequest = false) => resolveUrl(resourceUrl, isReloading, isMetadataRequest, id), [id, resolveUrl, url]);
   const register = useCallback(() => {
     if (!details) {
       dispatch(cardAction(ACTION_RESOLVING, {
@@ -134,36 +40,13 @@ export const useSmartCardActions = (id, url, analytics) => {
     return resolve();
   }, [details, resolve, dispatch, url, setMetadataStatus]);
   const reload = useCallback(() => {
-    var _details$data, _details$data$Type;
     const definitionId = getDefinitionId(details);
-
-    // Start: Smart link Actions experiment
-    if (definitionId === 'jira-object-provider' && details !== null && details !== void 0 && (_details$data = details.data) !== null && _details$data !== void 0 && (_details$data$Type = _details$data['@type']) !== null && _details$data$Type !== void 0 && _details$data$Type.includes('atlassian:Task')) {
-      // EDM-5149: This is part of actionable element experiment where we
-      // reload jira issue link after embed view modal is closed.
-      // In our component, `reload` is only used in auth flow which
-      // jira link, being Atlassian product, would not fall into this category
-      // and would not be reloaded in normal smart link context.
-      // The code from resolve is duplicated here to avoid changing the response
-      // shape of resolve.
-      const previousJiraStatus = extractLozengeText(details);
-      connections.client.fetchData(url, true).then(response => {
-        handleResolvedLinkResponse(url, response, true, false);
-        const jiraStatus = extractLozengeText(response);
-        analytics.track.linkUpdated({
-          actionSubjectId: 'jiraIssueStatus',
-          previousJiraStatus,
-          jiraStatus
-        });
-      }).catch(error => handleResolvedLinkError(url, error, undefined, false));
-    }
-    // End: Smart ink Actions experiment
-    else if (definitionId) {
+    if (definitionId) {
       getByDefinitionId(definitionId, getState()).map(url => resolve(url, true));
     } else {
       resolve(url, true);
     }
-  }, [details, connections.client, url, handleResolvedLinkResponse, analytics.track, handleResolvedLinkError, getState, resolve]);
+  }, [details, url, getState, resolve]);
   const loadMetadata = useCallback(() => {
     //metadataStatus will be undefined for SSR links only
     if (metadataStatus === undefined) {

package/dist/es2019/state/hooks/use-resolve/index.js

@@ -0,0 +1,131 @@
+import { useCallback } from 'react';
+import { addMetadataToExperience } from '../../analytics';
+import { getStatus } from '../../helpers';
+import { ACTION_ERROR, ACTION_ERROR_FALLBACK, ACTION_RELOADING, ACTION_RESOLVED, ACTION_UPDATE_METADATA_STATUS, APIError, cardAction } from '@atlaskit/linking-common';
+import { ERROR_MESSAGE_FATAL, ERROR_MESSAGE_METADATA, ERROR_MESSAGE_OAUTH } from '../../actions/constants';
+import { getUnauthorizedJsonLd } from '../../../utils/jsonld';
+import { SmartLinkStatus } from '../../../constants';
+import { useSmartLinkContext } from '@atlaskit/link-provider';
+const useResolve = () => {
+  // Request JSON-LD data for the card from ORS, if it has extended
+  // its cache lifespan OR there is no data for it currently. Once the data
+  // has come back asynchronously, dispatch the resolved action for the card.
+  const {
+    store,
+    connections,
+    config
+  } = useSmartLinkContext();
+  const {
+    getState,
+    dispatch
+  } = store;
+  const hasAuthFlowSupported = config.authFlow !== 'disabled';
+  const setMetadataStatus = useCallback((url, metadataStatus) => {
+    dispatch(cardAction(ACTION_UPDATE_METADATA_STATUS, {
+      url
+    }, undefined, undefined, metadataStatus));
+  }, [dispatch]);
+  const handleResolvedLinkError = useCallback((url, error, response, isMetadataRequest) => {
+    const {
+      details
+    } = getState()[url] || {
+      status: SmartLinkStatus.Pending,
+      details: undefined
+    };
+    const hasData = !!(details && details.data);
+
+    // If metadata request then set metadata status, return and do not alter link status
+    if (isMetadataRequest) {
+      setMetadataStatus(url, 'errored');
+      return;
+    }
+    if (error.kind === 'fatal') {
+      // If there's no previous data in the store for this URL, then bail
+      // out and let the editor handle fallbacks (returns to a blue link).
+      if (!hasData && status !== 'resolved') {
+        dispatch(cardAction(ACTION_ERROR, {
+          url
+        }, details, error));
+        throw error;
+      }
+      // If we already have resolved data for this URL in the store, then
+      // simply fallback to the previous data.
+      if (hasData) {
+        dispatch(cardAction(ACTION_RESOLVED, {
+          url
+        }, details));
+      }
+      // Handle AuthErrors (user did not have access to resource) -
+      // Missing AAID in ASAP claims, or missing UserContext, or 403 from downstream
+    } else if (error.kind === 'auth') {
+      dispatch(cardAction(ACTION_RESOLVED, {
+        url
+      }, getUnauthorizedJsonLd()));
+    } else {
+      if (error.kind === 'fallback') {
+        // Fallback to blue link with smart link formatting. Not part of reliability.
+        dispatch(cardAction(ACTION_ERROR_FALLBACK, {
+          url
+        }, response, error));
+      } else {
+        // Fallback to blue link with smart link formatting. Part of reliability.
+        dispatch(cardAction(ACTION_ERROR, {
+          url
+        }, undefined, error));
+      }
+    }
+  }, [getState, setMetadataStatus, dispatch]);
+  const handleResolvedLinkResponse = useCallback((resourceUrl, response, isReloading = false, isMetadataRequest) => {
+    const hostname = new URL(resourceUrl).hostname;
+    const nextStatus = response ? getStatus(response) : 'fatal';
+
+    // If we require authorization & do not have an authFlow available,
+    // throw an error and render as a normal blue link.
+    if ((nextStatus === 'unauthorized' || nextStatus === 'forbidden') && !hasAuthFlowSupported) {
+      handleResolvedLinkError(resourceUrl, new APIError('fallback', hostname, ERROR_MESSAGE_OAUTH), response, isMetadataRequest);
+      return;
+    }
+
+    // Handle any other errors
+    if (nextStatus === 'fatal') {
+      handleResolvedLinkError(resourceUrl, new APIError('fatal', hostname, ERROR_MESSAGE_FATAL), undefined, isMetadataRequest);
+      return;
+    }
+
+    // Handle errors of any other kind in the metadata request response
+    if (isMetadataRequest && nextStatus !== 'resolved') {
+      handleResolvedLinkError(resourceUrl, new APIError('error', hostname, ERROR_MESSAGE_METADATA), response, isMetadataRequest);
+      return;
+    }
+
+    //if a link resolves normally, metadata will also always be resolved
+    setMetadataStatus(resourceUrl, 'resolved');
+    // Dispatch Analytics and resolved card action - including unauthorized states.
+    if (isReloading) {
+      dispatch(cardAction(ACTION_RELOADING, {
+        url: resourceUrl
+      }, response));
+    } else {
+      dispatch(cardAction(ACTION_RESOLVED, {
+        url: resourceUrl
+      }, response, undefined, undefined, isMetadataRequest));
+    }
+  }, [dispatch, handleResolvedLinkError, hasAuthFlowSupported, setMetadataStatus]);
+  return useCallback(async (url, isReloading = false, isMetadataRequest = false, id = '') => {
+    const {
+      details
+    } = getState()[url] || {
+      status: SmartLinkStatus.Pending,
+      details: undefined
+    };
+    const hasData = !!(details && details.data);
+    if (isReloading || !hasData || isMetadataRequest) {
+      return connections.client.fetchData(url, isReloading).then(response => handleResolvedLinkResponse(url, response, isReloading, isMetadataRequest)).catch(error => handleResolvedLinkError(url, error, undefined, isMetadataRequest));
+    } else {
+      addMetadataToExperience('smart-link-rendered', id, {
+        cached: true
+      });
+    }
+  }, [connections.client, getState, handleResolvedLinkError, handleResolvedLinkResponse]);
+};
+export default useResolve;

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/smart-card",
-	"version": "25.4.1",
+	"version": "25.4.2",
 	"sideEffects": false
 }

package/dist/es2019/view/FlexibleCard/components/common/lozenge-action/index.js

@@ -12,6 +12,7 @@ import useInvoke from '../../../../../state/hooks/use-invoke';
 import { InvokeActionError } from '../../../../../state/hooks/use-invoke/types';
 import extractLozengeActionItems from '../../../../../extractors/action/extract-lozenge-action-items';
 import createStatusUpdateRequest from '../../../../../utils/actions/create-status-update-request';
+import useResolve from '../../../../../state/hooks/use-resolve';
 const validateItems = (items = [], text) => {
   return items.filter(item => item.text !== text);
 };
@@ -27,6 +28,7 @@ const LozengeAction = ({
   const [items, setItems] = useState();
   const [errorCode, setErrorCode] = useState();
   const invoke = useInvoke();
+  const reload = useResolve();
   const handleOpenChange = useCallback(async args => {
     setIsOpen(args.isOpen);
     if (args.isOpen && !isLoaded && action !== null && action !== void 0 && action.read) {
@@ -57,19 +59,27 @@ const LozengeAction = ({
   })), [appearance, testId, text]);
   const handleItemClick = useCallback(async id => {
     try {
-      if (action !== null && action !== void 0 && action.update && id) {
+      const updateAction = action === null || action === void 0 ? void 0 : action.update;
+      if (updateAction && id) {
         setIsLoading(true);
-        const request = createStatusUpdateRequest(action.update, id);
+        const request = createStatusUpdateRequest(updateAction, id);
         await invoke(request);
         setIsLoading(false);
         setIsOpen(false);
+        const {
+          url,
+          id: linkId
+        } = updateAction.details || {};
+        if (url) {
+          await reload(url, true, undefined, linkId);
+        }
       }
     } catch (err) {
       // TODO: EDM-6261: Error state
       setIsLoading(false);
       setErrorCode(InvokeActionError.Unknown);
     }
-  }, [action === null || action === void 0 ? void 0 : action.update, invoke]);
+  }, [action === null || action === void 0 ? void 0 : action.update, invoke, reload]);
   const dropdownItemGroup = useMemo(() => {
     if (errorCode) {
       return jsx(LozengeActionError, {

package/dist/esm/state/actions/index.js

@@ -4,19 +4,16 @@ function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyri
 import { useMemo, useCallback } from 'react';
 import { auth } from '@atlaskit/outbound-auth-flow-client';
 import { useSmartLinkContext } from '@atlaskit/link-provider';
-import { ACTION_RESOLVED, ACTION_ERROR, ACTION_ERROR_FALLBACK, ACTION_RELOADING, ACTION_UPDATE_METADATA_STATUS, cardAction, APIError, ACTION_RESOLVING } from '@atlaskit/linking-common';
-import { getDefinitionId, getByDefinitionId, getServices, getStatus, getExtensionKey } from '../helpers';
-import { ERROR_MESSAGE_OAUTH, ERROR_MESSAGE_FATAL, ERROR_MESSAGE_METADATA } from './constants';
+import { ACTION_UPDATE_METADATA_STATUS, cardAction, ACTION_RESOLVING } from '@atlaskit/linking-common';
+import { getDefinitionId, getByDefinitionId, getServices, getExtensionKey } from '../helpers';
 import * as measure from '../../utils/performance';
-import { getUnauthorizedJsonLd } from '../../utils/jsonld';
-import { addMetadataToExperience } from '../analytics';
 import { SmartLinkStatus } from '../../constants';
-import { extractLozengeText } from '../../extractors/common/lozenge/extractLozengeText';
+import useResolve from '../hooks/use-resolve';
 export var useSmartCardActions = function useSmartCardActions(id, url, analytics) {
+  var resolveUrl = useResolve();
   var _useSmartLinkContext = useSmartLinkContext(),
     store = _useSmartLinkContext.store,
-    connections = _useSmartLinkContext.connections,
-    config = _useSmartLinkContext.config;
+    connections = _useSmartLinkContext.connections;
   var getState = store.getState,
     dispatch = store.dispatch;
   var _ref = getState()[url] || {
@@ -26,93 +23,11 @@ export var useSmartCardActions = function useSmartCardActions(id, url, analytics
     details = _ref.details,
     status = _ref.status,
     metadataStatus = _ref.metadataStatus;
-  var hasAuthFlowSupported = config.authFlow !== 'disabled';
-  var hasData = !!(details && details.data);
   var setMetadataStatus = useCallback(function (metadataStatus) {
     dispatch(cardAction(ACTION_UPDATE_METADATA_STATUS, {
       url: url
     }, undefined, undefined, metadataStatus));
   }, [dispatch, url]);
-  var handleResolvedLinkError = useCallback(function (url, error, response, isMetadataRequest) {
-    // If metadata request then set metadata status, return and do not alter link status
-    if (isMetadataRequest) {
-      setMetadataStatus('errored');
-      return;
-    }
-    if (error.kind === 'fatal') {
-      // If there's no previous data in the store for this URL, then bail
-      // out and let the editor handle fallbacks (returns to a blue link).
-      if (!hasData && status !== 'resolved') {
-        dispatch(cardAction(ACTION_ERROR, {
-          url: url
-        }, details, error));
-        throw error;
-      }
-      // If we already have resolved data for this URL in the store, then
-      // simply fallback to the previous data.
-      if (hasData) {
-        dispatch(cardAction(ACTION_RESOLVED, {
-          url: url
-        }, details));
-      }
-      // Handle AuthErrors (user did not have access to resource) -
-      // Missing AAID in ASAP claims, or missing UserContext, or 403 from downstream
-    } else if (error.kind === 'auth') {
-      dispatch(cardAction(ACTION_RESOLVED, {
-        url: url
-      }, getUnauthorizedJsonLd()));
-    } else {
-      if (error.kind === 'fallback') {
-        // Fallback to blue link with smart link formatting. Not part of reliability.
-        dispatch(cardAction(ACTION_ERROR_FALLBACK, {
-          url: url
-        }, response, error));
-      } else {
-        // Fallback to blue link with smart link formatting. Part of reliability.
-        dispatch(cardAction(ACTION_ERROR, {
-          url: url
-        }, undefined, error));
-      }
-    }
-  }, [setMetadataStatus, hasData, status, dispatch, details]);
-  var handleResolvedLinkResponse = useCallback(function (resourceUrl, response) {
-    var isReloading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var isMetadataRequest = arguments.length > 3 ? arguments[3] : undefined;
-    var hostname = new URL(resourceUrl).hostname;
-    var nextStatus = response ? getStatus(response) : 'fatal';
-
-    // If we require authorization & do not have an authFlow available,
-    // throw an error and render as a normal blue link.
-    if ((nextStatus === 'unauthorized' || nextStatus === 'forbidden') && !hasAuthFlowSupported) {
-      handleResolvedLinkError(resourceUrl, new APIError('fallback', hostname, ERROR_MESSAGE_OAUTH), response, isMetadataRequest);
-      return;
-    }
-
-    // Handle any other errors
-    if (nextStatus === 'fatal') {
-      handleResolvedLinkError(resourceUrl, new APIError('fatal', hostname, ERROR_MESSAGE_FATAL), undefined, isMetadataRequest);
-      return;
-    }
-
-    // Handle errors of any other kind in the metadata request response
-    if (isMetadataRequest && nextStatus !== 'resolved') {
-      handleResolvedLinkError(resourceUrl, new APIError('error', hostname, ERROR_MESSAGE_METADATA), response, isMetadataRequest);
-      return;
-    }
-
-    //if a link resolves normally, metadata will also always be resolved
-    setMetadataStatus('resolved');
-    // Dispatch Analytics and resolved card action - including unauthorized states.
-    if (isReloading) {
-      dispatch(cardAction(ACTION_RELOADING, {
-        url: resourceUrl
-      }, response));
-    } else {
-      dispatch(cardAction(ACTION_RESOLVED, {
-        url: resourceUrl
-      }, response, undefined, undefined, isMetadataRequest));
-    }
-  }, [dispatch, handleResolvedLinkError, hasAuthFlowSupported, setMetadataStatus]);
   var resolve = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
     var resourceUrl,
       isReloading,
@@ -125,26 +40,14 @@ export var useSmartCardActions = function useSmartCardActions(id, url, analytics
             resourceUrl = _args.length > 0 && _args[0] !== undefined ? _args[0] : url;
             isReloading = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;
             isMetadataRequest = _args.length > 2 && _args[2] !== undefined ? _args[2] : false;
-            if (!(isReloading || !hasData || isMetadataRequest)) {
-              _context.next = 7;
-              break;
-            }
-            return _context.abrupt("return", connections.client.fetchData(resourceUrl, isReloading).then(function (response) {
-              return handleResolvedLinkResponse(resourceUrl, response, isReloading, isMetadataRequest);
-            }).catch(function (error) {
-              return handleResolvedLinkError(resourceUrl, error, undefined, isMetadataRequest);
-            }));
-          case 7:
-            addMetadataToExperience('smart-link-rendered', id, {
-              cached: true
-            });
-          case 8:
+            return _context.abrupt("return", resolveUrl(resourceUrl, isReloading, isMetadataRequest, id));
+          case 4:
           case "end":
             return _context.stop();
         }
       }
     }, _callee);
-  })), [url, hasData, connections.client, handleResolvedLinkResponse, handleResolvedLinkError, id]);
+  })), [id, resolveUrl, url]);
   var register = useCallback(function () {
     if (!details) {
       dispatch(cardAction(ACTION_RESOLVING, {
@@ -155,40 +58,15 @@ export var useSmartCardActions = function useSmartCardActions(id, url, analytics
     return resolve();
   }, [details, resolve, dispatch, url, setMetadataStatus]);
   var reload = useCallback(function () {
-    var _details$data, _details$data$Type;
     var definitionId = getDefinitionId(details);
-
-    // Start: Smart link Actions experiment
-    if (definitionId === 'jira-object-provider' && details !== null && details !== void 0 && (_details$data = details.data) !== null && _details$data !== void 0 && (_details$data$Type = _details$data['@type']) !== null && _details$data$Type !== void 0 && _details$data$Type.includes('atlassian:Task')) {
-      // EDM-5149: This is part of actionable element experiment where we
-      // reload jira issue link after embed view modal is closed.
-      // In our component, `reload` is only used in auth flow which
-      // jira link, being Atlassian product, would not fall into this category
-      // and would not be reloaded in normal smart link context.
-      // The code from resolve is duplicated here to avoid changing the response
-      // shape of resolve.
-      var previousJiraStatus = extractLozengeText(details);
-      connections.client.fetchData(url, true).then(function (response) {
-        handleResolvedLinkResponse(url, response, true, false);
-        var jiraStatus = extractLozengeText(response);
-        analytics.track.linkUpdated({
-          actionSubjectId: 'jiraIssueStatus',
-          previousJiraStatus: previousJiraStatus,
-          jiraStatus: jiraStatus
-        });
-      }).catch(function (error) {
-        return handleResolvedLinkError(url, error, undefined, false);
-      });
-    }
-    // End: Smart ink Actions experiment
-    else if (definitionId) {
+    if (definitionId) {
       getByDefinitionId(definitionId, getState()).map(function (url) {
         return resolve(url, true);
       });
     } else {
       resolve(url, true);
     }
-  }, [details, connections.client, url, handleResolvedLinkResponse, analytics.track, handleResolvedLinkError, getState, resolve]);
+  }, [details, url, getState, resolve]);
   var loadMetadata = useCallback(function () {
     //metadataStatus will be undefined for SSR links only
     if (metadataStatus === undefined) {