@atlaskit/smart-card 44.5.0 → 44.5.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/smart-card
 
+## 44.5.2
+
+### Patch Changes
+
+- [`4403ed7990e4b`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/4403ed7990e4b) -
+  Add smart-card internal state services and hooks for social proof and current site cloud id
+  retrieval.
+- Updated dependencies
+
+## 44.5.1
+
+### Patch Changes
+
+- [`9bf56e51dae31`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/9bf56e51dae31) -
+  Scope block card Rovo Chat action to eligible providers (Google, OneDrive, Slack, Teams, GitHub,
+  GitLab, Salesforce) using an allowlist instead of relying on the supportsRovoActions backend flag.
+- Updated dependencies
+
 ## 44.5.0
 
 ### Minor Changes

package/dist/cjs/extractors/flexible/actions/extract-rovo-chat-action.js

@@ -12,10 +12,10 @@ var _helpers = require("../../../state/helpers");
 var _canShowAction = require("../../../utils/actions/can-show-action");
 var _rovo = require("../../../utils/rovo");
 var _types = require("../../../view/Card/types");
-// For rovogrowth-640 post auth inline experiment
+// For rovogrowth-640 post auth inline experiment and block card experiment (NAVX-4814)
 var ELIGIBLE_EXTENSION_KEYS = new Set(['slack-object-provider', 'google-object-provider', 'onedrive-object-provider', 'github-object-provider', 'ms-teams-object-provider', 'gitlab-object-provider', 'salesforce-object-provider']);
 var extractRovoChatAction = function extractRovoChatAction(_ref) {
-  var _response$meta, _actionOptions$rovoCh;
+  var _actionOptions$rovoCh;
   var actionOptions = _ref.actionOptions,
     appearance = _ref.appearance,
     id = _ref.id,
@@ -29,12 +29,11 @@ var extractRovoChatAction = function extractRovoChatAction(_ref) {
   if (!isRovoChatEnabled) {
     return;
   }
-  var supportsRovoActions = response === null || response === void 0 || (_response$meta = response.meta) === null || _response$meta === void 0 || (_response$meta = _response$meta.supportedFeature) === null || _response$meta === void 0 ? void 0 : _response$meta.includes('RovoActions');
   var extensionKey = (0, _helpers.getExtensionKey)(response);
   var isGoogleProvider = extensionKey === 'google-object-provider';
   var is3PAuthRovoActionEnabled = isGoogleProvider && (0, _platformFeatureFlags.fg)('platform_sl_3p_auth_rovo_action_kill_switch');
   var is3PInlinePostAuthActionsEnabled = extensionKey !== undefined && ELIGIBLE_EXTENSION_KEYS.has(extensionKey) && (0, _platformFeatureFlags.fg)('rovogrowth-640-inline-action-nudge-fg') && (0, _expValEqualsNoExposure.expValEqualsNoExposure)('rovogrowth-640-inline-action-nudge-exp', 'isEnabled', true);
-  var is3PBlockPostAuthActionsEnabled = supportsRovoActions && (0, _platformFeatureFlags.fg)('platform_sl_3p_auth_rovo_block_card_kill_switch');
+  var is3PBlockPostAuthActionsEnabled = extensionKey !== undefined && ELIGIBLE_EXTENSION_KEYS.has(extensionKey) && (0, _platformFeatureFlags.fg)('platform_sl_3p_auth_rovo_block_card_kill_switch');
   var isSupportedFeature = is3PInlinePostAuthActionsEnabled || is3PAuthRovoActionEnabled || is3PBlockPostAuthActionsEnabled;
   var isOptIn = (actionOptions === null || actionOptions === void 0 || (_actionOptions$rovoCh = actionOptions.rovoChatAction) === null || _actionOptions$rovoCh === void 0 ? void 0 : _actionOptions$rovoCh.optIn) === true;
   var url = (0, _linkExtractors.extractSmartLinkUrl)(response);

package/dist/cjs/state/hooks/use-current-site-cloud-id/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY", {
+  enumerable: true,
+  get: function get() {
+    return _currentSiteCloudId.CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY;
+  }
+});
+Object.defineProperty(exports, "CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY", {
+  enumerable: true,
+  get: function get() {
+    return _currentSiteCloudId.CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY;
+  }
+});
+Object.defineProperty(exports, "currentSiteCloudIdService", {
+  enumerable: true,
+  get: function get() {
+    return _currentSiteCloudId.currentSiteCloudIdService;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "getCachedCurrentSiteCloudIdAndRefresh", {
+  enumerable: true,
+  get: function get() {
+    return _currentSiteCloudId.getCachedCurrentSiteCloudIdAndRefresh;
+  }
+});
+Object.defineProperty(exports, "getCurrentSiteCloudId", {
+  enumerable: true,
+  get: function get() {
+    return _currentSiteCloudId.getCurrentSiteCloudId;
+  }
+});
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _currentSiteCloudId = require("../../services/current-site-cloud-id");
+var useCurrentSiteCloudId = function useCurrentSiteCloudId() {
+  var _useState = (0, _react.useState)(undefined),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    cloudId = _useState2[0],
+    setCloudId = _useState2[1];
+  var _useState3 = (0, _react.useState)(true),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    isLoading = _useState4[0],
+    setIsLoading = _useState4[1];
+  (0, _react.useEffect)(function () {
+    var cancelled = false;
+    setIsLoading(true);
+    void (0, _currentSiteCloudId.getCurrentSiteCloudId)().then(function (id) {
+      if (!cancelled) {
+        setCloudId(id);
+      }
+    }).finally(function () {
+      if (!cancelled) {
+        setIsLoading(false);
+      }
+    });
+    return function () {
+      cancelled = true;
+    };
+  }, []);
+  return {
+    cloudId: cloudId,
+    isLoading: isLoading
+  };
+};
+var _default = exports.default = useCurrentSiteCloudId;

package/dist/cjs/state/hooks/use-social-proof/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _personalization = require("../../services/personalization");
+var NOT_ENABLED_RESULT = {
+  connectedPct: undefined,
+  isEnabled: false,
+  isLoading: false
+};
+
+/**
+ * Fetches provider usage percentage from the TAP Delivery personalization service when the
+ * killswitch allows it. Callers decide separately (e.g. via Statsig experiment) whether to
+ * surface that data in the UI.
+ */
+var useSocialProof = function useSocialProof(traitName, extensionKey) {
+  var isKillswitchOn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var isEnabled = isKillswitchOn;
+  var _useState = (0, _react.useState)(undefined),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    providerPctMap = _useState2[0],
+    setProviderPctMap = _useState2[1];
+  var _useState3 = (0, _react.useState)(false),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    isPersonalizationLoading = _useState4[0],
+    setIsPersonalizationLoading = _useState4[1];
+  (0, _react.useEffect)(function () {
+    if (!isEnabled) {
+      return;
+    }
+    var cancelled = false;
+    setIsPersonalizationLoading(true);
+    (0, _personalization.getProviderPctMap)(traitName).then(function (pctMap) {
+      if (!cancelled) {
+        setProviderPctMap(pctMap);
+        setIsPersonalizationLoading(false);
+      }
+    });
+    return function () {
+      cancelled = true;
+    };
+  }, [isEnabled, traitName]);
+  return (0, _react.useMemo)(function () {
+    if (!isEnabled) {
+      return NOT_ENABLED_RESULT;
+    }
+    return {
+      connectedPct: extensionKey && providerPctMap ? providerPctMap[extensionKey] : undefined,
+      isEnabled: isEnabled,
+      isLoading: isPersonalizationLoading
+    };
+  }, [extensionKey, isEnabled, isPersonalizationLoading, providerPctMap]);
+};
+var _default = exports.default = useSocialProof;

package/dist/cjs/state/services/current-site-cloud-id/index.js

@@ -0,0 +1,182 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.currentSiteCloudIdService = exports.CurrentSiteCloudIdService = exports.CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY = exports.CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY = void 0;
+exports.getCachedCurrentSiteCloudIdAndRefresh = getCachedCurrentSiteCloudIdAndRefresh;
+exports.getCurrentSiteCloudId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _storageClient = require("@atlaskit/frontend-utilities/storage-client");
+var _linkingCommon = require("@atlaskit/linking-common");
+/**
+ * Logical key shape matches smart-card storage conventions (see personalization-service). {@link StorageClient}
+ * stores rows as `<clientKey>_<itemKey>` with `clientKey === '@atlaskit/smart-card'` and
+ * `itemKey === 'site-cloud-id:v1'` (no further scope segments; unlike `pct-map:v1:`, this is a single fixed row).
+ */
+var SMART_CARD_STORAGE_SCOPE = '@atlaskit/smart-card';
+var CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY = exports.CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY = 'site-cloud-id:v1';
+var smartCardStorage = new _storageClient.StorageClient(SMART_CARD_STORAGE_SCOPE);
+
+/** Keys written by this service in localStorage when using {@link smartCardStorage}. */
+var CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY = exports.CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY = "".concat(SMART_CARD_STORAGE_SCOPE, "_").concat(CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY);
+var CurrentSiteCloudIdService = exports.CurrentSiteCloudIdService = /*#__PURE__*/function () {
+  function CurrentSiteCloudIdService() {
+    (0, _classCallCheck2.default)(this, CurrentSiteCloudIdService);
+    /**
+     * Holds the shared tenant_info work: one in-flight fetch, then (on success) a settled promise for the session cloud
+     * id so later callers never trigger another `tenant_info` in the same page lifetime (until {@link clearCache}).
+     */
+    (0, _defineProperty2.default)(this, "tenantInfoInflightPromise", null);
+  }
+  return (0, _createClass2.default)(CurrentSiteCloudIdService, [{
+    key: "readStoredCloudId",
+    value: function readStoredCloudId() {
+      try {
+        var cloudId = smartCardStorage.getItem(CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY);
+        if (typeof cloudId !== 'string' || !cloudId || cloudId === 'undefined') {
+          return undefined;
+        }
+        return cloudId;
+      } catch (_unused) {
+        return undefined;
+      }
+    }
+  }, {
+    key: "writeStoredCloudId",
+    value: function writeStoredCloudId(cloudId) {
+      if (!cloudId) {
+        return;
+      }
+      try {
+        smartCardStorage.setItemWithExpiry(CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY, cloudId);
+      } catch (_unused2) {
+        // Quota, private-mode, SSR, etc. — same intent as personalization-service.
+      }
+    }
+  }, {
+    key: "ensureTenantInfoInflightStarted",
+    value: function ensureTenantInfoInflightStarted(baseUriWithNoTrailingSlash) {
+      var _this = this;
+      if (this.tenantInfoInflightPromise !== null) {
+        return;
+      }
+      this.tenantInfoInflightPromise = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var response, cloudId;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return (0, _linkingCommon.request)('get', baseUriWithNoTrailingSlash + '/_edge/tenant_info');
+            case 3:
+              response = _context.sent;
+              cloudId = response === null || response === void 0 ? void 0 : response.cloudId;
+              if (cloudId) {
+                _this.writeStoredCloudId(cloudId);
+              }
+              return _context.abrupt("return", cloudId ? cloudId : _this.readStoredCloudId());
+            case 9:
+              _context.prev = 9;
+              _context.t0 = _context["catch"](0);
+              _this.tenantInfoInflightPromise = null;
+              return _context.abrupt("return", _this.readStoredCloudId());
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 9]]);
+      }))();
+    }
+
+    /**
+     * Returns the currently cached cloud id synchronously and starts a background refresh.
+     * The refresh result is persisted for future calls but is not awaited by this call.
+     */
+  }, {
+    key: "getCachedCloudIdAndRefresh",
+    value: function getCachedCloudIdAndRefresh() {
+      this.ensureTenantInfoInflightStarted('');
+      return this.readStoredCloudId();
+    }
+
+    /** Writes tenant cloud id for tests or callers that intentionally warm storage before edge resolves. */
+  }, {
+    key: "persistStoredCloudId",
+    value: function persistStoredCloudId(cloudId) {
+      this.writeStoredCloudId(cloudId);
+    }
+
+    /**
+     * When local storage already has a tenant cloud id, it is returned immediately; a background tenant_info refresh
+     * is still kicked off unless one is already in flight.
+     *
+     * Without storage, this awaits the deduped in-flight tenant_info (first concurrent caller chooses the URL;
+     * all share one promise regardless of subsequent `baseUriWithNoTrailingSlash`).
+     *
+     * On network success with no cloud id, or on failure: falls back via {@link readStoredCloudId}.
+     */
+  }, {
+    key: "get",
+    value: (function () {
+      var _get = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var baseUriWithNoTrailingSlash,
+          fromStorage,
+          _args2 = arguments;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              baseUriWithNoTrailingSlash = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : '';
+              fromStorage = this.readStoredCloudId();
+              this.ensureTenantInfoInflightStarted(baseUriWithNoTrailingSlash);
+              if (!fromStorage) {
+                _context2.next = 5;
+                break;
+              }
+              return _context2.abrupt("return", fromStorage);
+            case 5:
+              return _context2.abrupt("return", this.tenantInfoInflightPromise);
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function get() {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }() /** Clears the session pin so the next {@link get} may run `tenant_info` again (e.g. tests). */)
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      this.tenantInfoInflightPromise = null;
+    }
+  }]);
+}();
+var currentSiteCloudIdService = exports.currentSiteCloudIdService = new CurrentSiteCloudIdService();
+
+/**
+ * Resolves the current site cloud id through the module-level {@link currentSiteCloudIdService}.
+ * Returns a stored cloud id immediately when one exists; otherwise waits for the shared
+ * `tenant_info` request and persists the result for subsequent cached reads.
+ */
+var getCurrentSiteCloudId = exports.getCurrentSiteCloudId = function getCurrentSiteCloudId() {
+  var baseUriWithNoTrailingSlash = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return currentSiteCloudIdService.get(baseUriWithNoTrailingSlash);
+};
+
+/**
+ * Reads the current site cloud id from browser storage (the `site-cloud-id:v1` row) via the
+ * module-level {@link currentSiteCloudIdService} singleton, without awaiting network work.
+ * Calling this also starts the shared `tenant_info` refresh in the background when one is not
+ * already running, so a later call can observe a refreshed value when available.
+ */
+function getCachedCurrentSiteCloudIdAndRefresh() {
+  return currentSiteCloudIdService.getCachedCloudIdAndRefresh();
+}

package/dist/cjs/state/services/personalization/index.js

@@ -0,0 +1,267 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PersonalizationService = exports.PERSONALIZATION_STORAGE_SCOPE = exports.PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX = void 0;
+exports.getCachedProviderPctMapAndRefresh = getCachedProviderPctMapAndRefresh;
+exports.personalizationService = exports.getProviderPctMap = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _storageClient = require("@atlaskit/frontend-utilities/storage-client");
+var _currentSiteCloudId = require("../current-site-cloud-id");
+var BASE_URL = '/gateway/api/tap-delivery/api/v3/personalization';
+
+/**
+ * Logical key shape: `@atlaskit/smart-card:<feature>:<schema-version>:<scope>` (see smart-card
+ * storage conventions). {@link StorageClient} narrows the localStorage key to
+ * `<clientKey>_<itemKey>` with `clientKey === '@atlaskit/smart-card'` and
+ * `itemKey === 'pct-map:v1:<cloudId>:<traitName>'` (scope segments URI-encoded).
+ */
+var PERSONALIZATION_STORAGE_SCOPE = exports.PERSONALIZATION_STORAGE_SCOPE = '@atlaskit/smart-card';
+var PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX = exports.PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX = 'pct-map:v1:';
+var smartCardStorage = new _storageClient.StorageClient(PERSONALIZATION_STORAGE_SCOPE);
+
+/** Keys written by this service in localStorage when using {@link smartCardStorage}. */
+var LOCAL_STORAGE_ROW_KEY_PREFIX = "".concat(PERSONALIZATION_STORAGE_SCOPE, "_").concat(PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX);
+function pctMapStorageItemKey(cloudId, traitName) {
+  return "".concat(PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX).concat(encodeURIComponent(cloudId), ":").concat(encodeURIComponent(traitName));
+}
+function fetchSiteTraits(_x) {
+  return _fetchSiteTraits.apply(this, arguments);
+}
+/**
+ * Service for fetching site-level traits from the TAP Delivery personalization API.
+ */
+function _fetchSiteTraits() {
+  _fetchSiteTraits = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(cloudId) {
+    var _data$attributes;
+    var response, data;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return fetch("".concat(BASE_URL, "/site/").concat(cloudId), {
+            method: 'GET',
+            credentials: 'include',
+            headers: {
+              'Content-Type': 'application/json'
+            }
+          });
+        case 2:
+          response = _context3.sent;
+          if (response.ok) {
+            _context3.next = 5;
+            break;
+          }
+          return _context3.abrupt("return", []);
+        case 5:
+          _context3.next = 7;
+          return response.json();
+        case 7:
+          data = _context3.sent;
+          return _context3.abrupt("return", (_data$attributes = data === null || data === void 0 ? void 0 : data.attributes) !== null && _data$attributes !== void 0 ? _data$attributes : []);
+        case 9:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _fetchSiteTraits.apply(this, arguments);
+}
+var PersonalizationService = exports.PersonalizationService = /*#__PURE__*/function () {
+  function PersonalizationService() {
+    (0, _classCallCheck2.default)(this, PersonalizationService);
+    (0, _defineProperty2.default)(this, "cache", new Map());
+  }
+  return (0, _createClass2.default)(PersonalizationService, [{
+    key: "getCachedProviderPctMapAndRefresh",
+    value:
+    /**
+     * Returns the currently cached provider percentage map synchronously and starts a background refresh.
+     * The refresh result is persisted for future calls but is not awaited by this call.
+     */
+    function getCachedProviderPctMapAndRefresh(traitName) {
+      var cloudId = (0, _currentSiteCloudId.getCachedCurrentSiteCloudIdAndRefresh)();
+      var fromStorage = cloudId && this.readStoredProviderPctMap(cloudId, traitName) || null;
+      void this.getProviderPctMap(traitName);
+      return fromStorage;
+    }
+  }, {
+    key: "getProviderPctMap",
+    value: function () {
+      var _getProviderPctMap = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(traitName) {
+        var _this = this;
+        var cachedPromise, promise;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              cachedPromise = this.cache.get(traitName);
+              if (!cachedPromise) {
+                _context2.next = 3;
+                break;
+              }
+              return _context2.abrupt("return", cachedPromise);
+            case 3:
+              promise = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+                var cloudId, traits, trait, mapped;
+                return _regenerator.default.wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      _context.prev = 0;
+                      _context.next = 3;
+                      return (0, _currentSiteCloudId.getCurrentSiteCloudId)();
+                    case 3:
+                      cloudId = _context.sent;
+                      if (cloudId) {
+                        _context.next = 6;
+                        break;
+                      }
+                      return _context.abrupt("return", undefined);
+                    case 6:
+                      _context.next = 8;
+                      return fetchSiteTraits(cloudId);
+                    case 8:
+                      traits = _context.sent;
+                      trait = traits.find(function (t) {
+                        return t.name === traitName;
+                      });
+                      mapped = _this.parseTraitValue(trait === null || trait === void 0 ? void 0 : trait.value);
+                      if (mapped !== undefined) {
+                        _this.writeStoredProviderPctMap(cloudId, traitName, mapped);
+                      }
+                      return _context.abrupt("return", mapped);
+                    case 15:
+                      _context.prev = 15;
+                      _context.t0 = _context["catch"](0);
+                      return _context.abrupt("return", undefined);
+                    case 18:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee, null, [[0, 15]]);
+              }))();
+              this.cache.set(traitName, promise);
+              return _context2.abrupt("return", promise);
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getProviderPctMap(_x2) {
+        return _getProviderPctMap.apply(this, arguments);
+      }
+      return getProviderPctMap;
+    }()
+  }, {
+    key: "readStoredProviderPctMap",
+    value: function readStoredProviderPctMap(cloudId, traitName) {
+      try {
+        var stored = smartCardStorage.getItem(pctMapStorageItemKey(cloudId, traitName));
+        if (stored === undefined || stored === null) {
+          return null;
+        }
+        return this.normalizeProviderPctMap(stored);
+      } catch (_unused2) {
+        return null;
+      }
+    }
+  }, {
+    key: "writeStoredProviderPctMap",
+    value: function writeStoredProviderPctMap(cloudId, traitName, map) {
+      try {
+        smartCardStorage.setItemWithExpiry(pctMapStorageItemKey(cloudId, traitName), map);
+      } catch (_unused3) {
+        // Quota, private-mode, etc.
+      }
+    }
+  }, {
+    key: "normalizeProviderPctMap",
+    value: function normalizeProviderPctMap(value) {
+      if ((0, _typeof2.default)(value) !== 'object' || value === null || Array.isArray(value)) {
+        return null;
+      }
+      var map = {};
+      var entries = Object.entries(value);
+      for (var _i = 0, _entries = entries; _i < _entries.length; _i++) {
+        var _entries$_i = (0, _slicedToArray2.default)(_entries[_i], 2),
+          providerKey = _entries$_i[0],
+          percentageRaw = _entries$_i[1];
+        if (typeof percentageRaw !== 'number' || !Number.isFinite(percentageRaw)) {
+          return null;
+        }
+        map[providerKey] = percentageRaw;
+      }
+      return map;
+    }
+  }, {
+    key: "parseTraitValue",
+    value: function parseTraitValue(raw) {
+      if (typeof raw !== 'string') {
+        return undefined;
+      }
+      try {
+        var parsed = JSON.parse(raw);
+        var normalized = this.normalizeProviderPctMap(parsed);
+        return normalized === null ? undefined : normalized;
+      } catch (_unused4) {
+        return undefined;
+      }
+    }
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      this.cache.clear();
+      this.clearStoredProviderPctMaps();
+    }
+  }, {
+    key: "clearStoredProviderPctMaps",
+    value: function clearStoredProviderPctMaps() {
+      if (typeof globalThis.localStorage === 'undefined' || globalThis.localStorage === null) {
+        return;
+      }
+      var keysToRemove = [];
+      for (var index = 0; index < globalThis.localStorage.length; index += 1) {
+        var key = globalThis.localStorage.key(index);
+        if (key !== null && key.startsWith(LOCAL_STORAGE_ROW_KEY_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      for (var _i2 = 0, _keysToRemove = keysToRemove; _i2 < _keysToRemove.length; _i2++) {
+        var _key = _keysToRemove[_i2];
+        try {
+          globalThis.localStorage.removeItem(_key);
+        } catch (_unused5) {
+          /* ignore */
+        }
+      }
+    }
+  }]);
+}();
+var personalizationService = exports.personalizationService = new PersonalizationService();
+
+/**
+ * Resolves the provider percentage map for a TAP Delivery trait through the module-level
+ * {@link personalizationService}. Work is deduped per trait name for the page lifetime, and a
+ * successful response is persisted by cloud id and trait name for later cached reads.
+ */
+var getProviderPctMap = exports.getProviderPctMap = function getProviderPctMap(traitName) {
+  return personalizationService.getProviderPctMap(traitName);
+};
+
+/**
+ * Reads the provider percentage map for a trait from browser storage via the module-level
+ * {@link personalizationService} singleton, without awaiting network work.
+ * Calling this also starts the trait-scoped shared refresh in the background, so a later call can
+ * use a refreshed value when it becomes available.
+ */
+function getCachedProviderPctMapAndRefresh(traitName) {
+  return personalizationService.getCachedProviderPctMapAndRefresh(traitName);
+}

package/dist/cjs/state/services/personalization/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/utils/analytics/analytics.js

@@ -11,7 +11,7 @@ var ANALYTICS_CHANNEL = exports.ANALYTICS_CHANNEL = 'media';
 var context = exports.context = {
   componentName: 'smart-cards',
   packageName: "@atlaskit/smart-card" || '',
-  packageVersion: "44.4.0" || ''
+  packageVersion: "44.5.1" || ''
 };
 var TrackQuickActionType = exports.TrackQuickActionType = /*#__PURE__*/function (TrackQuickActionType) {
   TrackQuickActionType["StatusUpdate"] = "StatusUpdate";

package/dist/cjs/view/LinkUrl/index.js

@@ -22,7 +22,7 @@ var _excluded = ["href", "children", "checkSafety", "onClick", "testId", "isLink
   _excluded2 = ["isLinkSafe", "showSafetyWarningModal"];
 var PACKAGE_DATA = {
   packageName: "@atlaskit/smart-card",
-  packageVersion: "44.4.0",
+  packageVersion: "44.5.1",
   componentName: 'linkUrl'
 };
 var Anchor = (0, _click.withLinkClickedEvent)('a');