@atlaskit/editor-card-provider 6.4.8 → 6.4.9

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atlaskit/editor-card-provider
 
+## 6.4.9
+
+### Patch Changes
+
+- [`50a2e34ed2f69`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/50a2e34ed2f69) -
+  Optimize SmartCardLocalCacheClient: in-memory caching, async writes, singleton pattern, and write
+  batching.
+- Updated dependencies
+
 ## 6.4.8
 
 ### Patch Changes

package/dist/cjs/provider.js

@@ -141,7 +141,7 @@ var EditorCardProvider = exports.EditorCardProvider = /*#__PURE__*/function (_re
     var _this;
     (0, _classCallCheck2.default)(this, EditorCardProvider);
     _this = _callSuper(this, EditorCardProvider);
-    (0, _defineProperty2.default)(_this, "smartCardLocalCacheClient", new _smartCardLocalCacheClient.SmartCardLocalCacheClient());
+    (0, _defineProperty2.default)(_this, "smartCardLocalCacheClient", _smartCardLocalCacheClient.SmartCardLocalCacheClient.getInstance());
     _this.name = 'editorCardProvider';
     _this.baseUrl = baseUrlOverride || (0, _linkingCommon.getBaseUrl)(envKey);
     _this.resolverUrl = (0, _linkingCommon.getResolverUrl)(envKey, baseUrlOverride);

package/dist/cjs/smart-card-local-cache-client.js

@@ -5,82 +5,131 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SmartCardLocalCacheClient = void 0;
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 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 SMART_CARD_CACHE_CLIENT_KEY = 'smart-card-url-data';
 var SMART_CARD_CACHE_KEY = 'response-cache';
 var SMART_CARD_CACHE_DEFAULT_MAX_ITEMS = 100;
-var SmartCardLocalCacheClient = exports.SmartCardLocalCacheClient = /*#__PURE__*/(0, _createClass2.default)(function SmartCardLocalCacheClient() {
-  var _this = this;
-  var maxItems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SMART_CARD_CACHE_DEFAULT_MAX_ITEMS;
-  (0, _classCallCheck2.default)(this, SmartCardLocalCacheClient);
-  (0, _defineProperty2.default)(this, "storageClient", new _storageClient.StorageClient(SMART_CARD_CACHE_CLIENT_KEY, {
-    storageEngine: 'sessionStorage'
-  }));
-  /**
-   * Retrieves the entire cache object from storage
-   * @returns The entire cache object
-   */
-  (0, _defineProperty2.default)(this, "getCache", function () {
-    var stored = _this.storageClient.getItem(SMART_CARD_CACHE_KEY, {
-      useExpiredItem: true
+/**
+ * Singleton cache client for smart link responses. Uses sessionStorage for per-tab isolation (no cross-tab conflicts).
+ * If switching to localStorage for cross-tab sharing, add a 'storage' event listener in the constructor to sync
+ * memoryCache when other tabs modify the cache, preventing race conditions from concurrent writes.
+ */
+var SmartCardLocalCacheClient = exports.SmartCardLocalCacheClient = /*#__PURE__*/function () {
+  function SmartCardLocalCacheClient() {
+    var _this = this;
+    var maxItems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SMART_CARD_CACHE_DEFAULT_MAX_ITEMS;
+    (0, _classCallCheck2.default)(this, SmartCardLocalCacheClient);
+    (0, _defineProperty2.default)(this, "storageClient", new _storageClient.StorageClient(SMART_CARD_CACHE_CLIENT_KEY, {
+      storageEngine: 'sessionStorage'
+    }));
+    (0, _defineProperty2.default)(this, "pendingWrite", false);
+    /**
+     * Retrieves the entire cache object from memory
+     * @returns The entire cache object
+     */
+    (0, _defineProperty2.default)(this, "getCache", function () {
+      return _this.memoryCache;
     });
-    var persistentCache = stored ? JSON.parse(stored) : {};
-    return persistentCache;
-  });
-  /**
-   * Caches the SmartLinkResponse against the provided url in storage
-   * @param url The url (key) to store the response against
-   * @param response The SmartLinkResponse to be cached in storage
-   */
-  (0, _defineProperty2.default)(this, "setItem", function (url, response) {
-    var newCache = _this.getCache();
+    /**
+     * Caches the SmartLinkResponse against the provided url in storage
+     * @param url The url (key) to store the response against
+     * @param response The SmartLinkResponse to be cached in storage
+     */
+    (0, _defineProperty2.default)(this, "setItem", function (url, response) {
+      // Add or update the item in the cache with current timestamp
+      _this.memoryCache[url] = {
+        data: response,
+        timestamp: Date.now()
+      };
 
-    // Add or update the item in the cache with current timestamp
-    newCache[url] = {
-      data: response,
-      timestamp: Date.now()
-    };
+      // Apply FIFO behavior if cache exceeds maxItems
+      var cacheKeys = Object.keys(_this.memoryCache);
+      if (cacheKeys.length > _this.maxItems) {
+        // Sort keys by timestamp (oldest first) and remove the oldest items
+        var sortedKeys = cacheKeys.sort(function (a, b) {
+          return _this.memoryCache[a].timestamp - _this.memoryCache[b].timestamp;
+        });
+        var itemsToRemove = cacheKeys.length - _this.maxItems;
+        var keysToRemove = sortedKeys.slice(0, itemsToRemove);
+        keysToRemove.forEach(function (key) {
+          delete _this.memoryCache[key];
+        });
+      }
+
+      // Write through to storage asynchronously (non-blocking)
+      // Debounced to batch multiple rapid calls into a single write
+      if (!_this.pendingWrite) {
+        _this.pendingWrite = true;
+        queueMicrotask(function () {
+          try {
+            _this.storageClient.setItemWithExpiry(SMART_CARD_CACHE_KEY, JSON.stringify(_this.memoryCache));
+          } catch (_) {
+            // Ignore storage write errors (e.g. quota exceeded) to prevent blocking future writes
+            // Cache will still function in-memory for the session, but won't persist
+          } finally {
+            _this.pendingWrite = false;
+          }
+        });
+      }
+    });
+    /**
+     * Retrieves the cached SmartLinkResponse for the provided url from storage (if it exists)
+     * @param url The url (key) to retrieve the cached response for
+     * @returns The cached SmartLinkResponse if it exists, else undefined
+     */
+    (0, _defineProperty2.default)(this, "getItem", function (url) {
+      var _this$memoryCache;
+      if (!url) {
+        return;
+      }
+      var response = (_this$memoryCache = _this.memoryCache) === null || _this$memoryCache === void 0 || (_this$memoryCache = _this$memoryCache[url]) === null || _this$memoryCache === void 0 ? void 0 : _this$memoryCache.data;
+      return response;
+    });
+    /**
+     * Checks if a cached entry exists for the provided url in storage
+     * @param url The url (key) to check for existence in the cache
+     * @returns True if a cached entry exists, else false
+     */
+    (0, _defineProperty2.default)(this, "isUrlInCache", function (url) {
+      return url in _this.memoryCache;
+    });
+    this.maxItems = maxItems;
+    // Load cache from storage into memory on instantiation
+    var stored = this.storageClient.getItem(SMART_CARD_CACHE_KEY, {
+      useExpiredItem: true
+    });
+    this.memoryCache = stored ? JSON.parse(stored) : {};
+  }
 
-    // Apply FIFO behavior if cache exceeds maxItems
-    var cacheKeys = Object.keys(newCache);
-    if (cacheKeys.length > _this.maxItems) {
-      // Sort keys by timestamp (oldest first) and remove the oldest items
-      var sortedKeys = cacheKeys.sort(function (a, b) {
-        return newCache[a].timestamp - newCache[b].timestamp;
-      });
-      var itemsToRemove = cacheKeys.length - _this.maxItems;
-      var keysToRemove = sortedKeys.slice(0, itemsToRemove);
-      keysToRemove.forEach(function (key) {
-        delete newCache[key];
-      });
-    }
-    _this.storageClient.setItemWithExpiry(SMART_CARD_CACHE_KEY, JSON.stringify(newCache));
-  });
   /**
-   * Retrieves the cached SmartLinkResponse for the provided url from storage (if it exists)
-   * @param url The url (key) to retrieve the cached response for
-   * @returns The cached SmartLinkResponse if it exists, else undefined
+   * Gets the singleton instance of SmartCardLocalCacheClient.
+   * This ensures all callers share the same in-memory cache and prevents
+   * race conditions when multiple instances write to the same storage key.
+   * @param maxItems Maximum number of items to store in the cache (only used on first instantiation)
+   * @returns The singleton instance
    */
-  (0, _defineProperty2.default)(this, "getItem", function (url) {
-    var _persistentCache$url;
-    if (!url) {
-      return;
+  return (0, _createClass2.default)(SmartCardLocalCacheClient, null, [{
+    key: "getInstance",
+    value: function getInstance() {
+      var maxItems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SMART_CARD_CACHE_DEFAULT_MAX_ITEMS;
+      if (!SmartCardLocalCacheClient.instance) {
+        SmartCardLocalCacheClient.instance = new SmartCardLocalCacheClient(maxItems);
+      }
+      return SmartCardLocalCacheClient.instance;
     }
-    var persistentCache = _this.getCache();
-    var response = persistentCache === null || persistentCache === void 0 || (_persistentCache$url = persistentCache[url]) === null || _persistentCache$url === void 0 ? void 0 : _persistentCache$url.data;
-    return response;
-  });
-  /**
-   * Checks if a cached entry exists for the provided url in storage
-   * @param url The url (key) to check for existence in the cache
-   * @returns True if a cached entry exists, else false
-   */
-  (0, _defineProperty2.default)(this, "isUrlInCache", function (url) {
-    var persistentCache = _this.getCache();
-    return persistentCache ? url in persistentCache : false;
-  });
-  this.maxItems = maxItems;
-});
+
+    /**
+     * Resets the singleton instance. Only intended for testing purposes.
+     * @internal
+     */
+  }, {
+    key: "resetInstance",
+    value: function resetInstance() {
+      SmartCardLocalCacheClient.instance = null;
+    }
+  }]);
+}();
+(0, _defineProperty2.default)(SmartCardLocalCacheClient, "instance", null);

package/dist/es2019/provider.js

@@ -72,7 +72,7 @@ export const isJiraWorkItem = url => /\/browse\/((?:\w+)-(?:\d+))/i.test(url);
 export class EditorCardProvider extends NodeDataProvider {
   constructor(envKey, baseUrlOverride, product, onResolve, customCardClient) {
     super();
-    _defineProperty(this, "smartCardLocalCacheClient", new SmartCardLocalCacheClient());
+    _defineProperty(this, "smartCardLocalCacheClient", SmartCardLocalCacheClient.getInstance());
     this.name = 'editorCardProvider';
     this.baseUrl = baseUrlOverride || getBaseUrl(envKey);
     this.resolverUrl = getResolverUrl(envKey, baseUrlOverride);

package/dist/es2019/smart-card-local-cache-client.js

@@ -3,21 +3,23 @@ import { StorageClient } from '@atlaskit/frontend-utilities/storage-client';
 const SMART_CARD_CACHE_CLIENT_KEY = 'smart-card-url-data';
 const SMART_CARD_CACHE_KEY = 'response-cache';
 const SMART_CARD_CACHE_DEFAULT_MAX_ITEMS = 100;
+/**
+ * Singleton cache client for smart link responses. Uses sessionStorage for per-tab isolation (no cross-tab conflicts).
+ * If switching to localStorage for cross-tab sharing, add a 'storage' event listener in the constructor to sync
+ * memoryCache when other tabs modify the cache, preventing race conditions from concurrent writes.
+ */
 export class SmartCardLocalCacheClient {
   constructor(maxItems = SMART_CARD_CACHE_DEFAULT_MAX_ITEMS) {
     _defineProperty(this, "storageClient", new StorageClient(SMART_CARD_CACHE_CLIENT_KEY, {
       storageEngine: 'sessionStorage'
     }));
+    _defineProperty(this, "pendingWrite", false);
     /**
-     * Retrieves the entire cache object from storage
+     * Retrieves the entire cache object from memory
      * @returns The entire cache object
      */
     _defineProperty(this, "getCache", () => {
-      const stored = this.storageClient.getItem(SMART_CARD_CACHE_KEY, {
-        useExpiredItem: true
-      });
-      const persistentCache = stored ? JSON.parse(stored) : {};
-      return persistentCache;
+      return this.memoryCache;
     });
     /**
      * Caches the SmartLinkResponse against the provided url in storage
@@ -25,26 +27,39 @@ export class SmartCardLocalCacheClient {
      * @param response The SmartLinkResponse to be cached in storage
      */
     _defineProperty(this, "setItem", (url, response) => {
-      const newCache = this.getCache();
-
       // Add or update the item in the cache with current timestamp
-      newCache[url] = {
+      this.memoryCache[url] = {
         data: response,
         timestamp: Date.now()
       };
 
       // Apply FIFO behavior if cache exceeds maxItems
-      const cacheKeys = Object.keys(newCache);
+      const cacheKeys = Object.keys(this.memoryCache);
       if (cacheKeys.length > this.maxItems) {
         // Sort keys by timestamp (oldest first) and remove the oldest items
-        const sortedKeys = cacheKeys.sort((a, b) => newCache[a].timestamp - newCache[b].timestamp);
+        const sortedKeys = cacheKeys.sort((a, b) => this.memoryCache[a].timestamp - this.memoryCache[b].timestamp);
         const itemsToRemove = cacheKeys.length - this.maxItems;
         const keysToRemove = sortedKeys.slice(0, itemsToRemove);
         keysToRemove.forEach(key => {
-          delete newCache[key];
+          delete this.memoryCache[key];
+        });
+      }
+
+      // Write through to storage asynchronously (non-blocking)
+      // Debounced to batch multiple rapid calls into a single write
+      if (!this.pendingWrite) {
+        this.pendingWrite = true;
+        queueMicrotask(() => {
+          try {
+            this.storageClient.setItemWithExpiry(SMART_CARD_CACHE_KEY, JSON.stringify(this.memoryCache));
+          } catch (_) {
+            // Ignore storage write errors (e.g. quota exceeded) to prevent blocking future writes
+            // Cache will still function in-memory for the session, but won't persist
+          } finally {
+            this.pendingWrite = false;
+          }
         });
       }
-      this.storageClient.setItemWithExpiry(SMART_CARD_CACHE_KEY, JSON.stringify(newCache));
     });
     /**
      * Retrieves the cached SmartLinkResponse for the provided url from storage (if it exists)
@@ -52,12 +67,11 @@ export class SmartCardLocalCacheClient {
      * @returns The cached SmartLinkResponse if it exists, else undefined
      */
     _defineProperty(this, "getItem", url => {
-      var _persistentCache$url;
+      var _this$memoryCache, _this$memoryCache$url;
       if (!url) {
         return;
       }
-      const persistentCache = this.getCache();
-      const response = persistentCache === null || persistentCache === void 0 ? void 0 : (_persistentCache$url = persistentCache[url]) === null || _persistentCache$url === void 0 ? void 0 : _persistentCache$url.data;
+      const response = (_this$memoryCache = this.memoryCache) === null || _this$memoryCache === void 0 ? void 0 : (_this$memoryCache$url = _this$memoryCache[url]) === null || _this$memoryCache$url === void 0 ? void 0 : _this$memoryCache$url.data;
       return response;
     });
     /**
@@ -66,9 +80,36 @@ export class SmartCardLocalCacheClient {
      * @returns True if a cached entry exists, else false
      */
     _defineProperty(this, "isUrlInCache", url => {
-      const persistentCache = this.getCache();
-      return persistentCache ? url in persistentCache : false;
+      return url in this.memoryCache;
     });
     this.maxItems = maxItems;
+    // Load cache from storage into memory on instantiation
+    const stored = this.storageClient.getItem(SMART_CARD_CACHE_KEY, {
+      useExpiredItem: true
+    });
+    this.memoryCache = stored ? JSON.parse(stored) : {};
+  }
+
+  /**
+   * Gets the singleton instance of SmartCardLocalCacheClient.
+   * This ensures all callers share the same in-memory cache and prevents
+   * race conditions when multiple instances write to the same storage key.
+   * @param maxItems Maximum number of items to store in the cache (only used on first instantiation)
+   * @returns The singleton instance
+   */
+  static getInstance(maxItems = SMART_CARD_CACHE_DEFAULT_MAX_ITEMS) {
+    if (!SmartCardLocalCacheClient.instance) {
+      SmartCardLocalCacheClient.instance = new SmartCardLocalCacheClient(maxItems);
+    }
+    return SmartCardLocalCacheClient.instance;
+  }
+
+  /**
+   * Resets the singleton instance. Only intended for testing purposes.
+   * @internal
+   */
+  static resetInstance() {
+    SmartCardLocalCacheClient.instance = null;
   }
-}
+}
+_defineProperty(SmartCardLocalCacheClient, "instance", null);

package/dist/esm/provider.js

@@ -136,7 +136,7 @@ export var EditorCardProvider = /*#__PURE__*/function (_ref) {
     var _this;
     _classCallCheck(this, EditorCardProvider);
     _this = _callSuper(this, EditorCardProvider);
-    _defineProperty(_this, "smartCardLocalCacheClient", new SmartCardLocalCacheClient());
+    _defineProperty(_this, "smartCardLocalCacheClient", SmartCardLocalCacheClient.getInstance());
     _this.name = 'editorCardProvider';
     _this.baseUrl = baseUrlOverride || getBaseUrl(envKey);
     _this.resolverUrl = getResolverUrl(envKey, baseUrlOverride);

package/dist/esm/smart-card-local-cache-client.js

@@ -1,79 +1,128 @@
-import _createClass from "@babel/runtime/helpers/createClass";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { StorageClient } from '@atlaskit/frontend-utilities/storage-client';
 var SMART_CARD_CACHE_CLIENT_KEY = 'smart-card-url-data';
 var SMART_CARD_CACHE_KEY = 'response-cache';
 var SMART_CARD_CACHE_DEFAULT_MAX_ITEMS = 100;
-export var SmartCardLocalCacheClient = /*#__PURE__*/_createClass(function SmartCardLocalCacheClient() {
-  var _this = this;
-  var maxItems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SMART_CARD_CACHE_DEFAULT_MAX_ITEMS;
-  _classCallCheck(this, SmartCardLocalCacheClient);
-  _defineProperty(this, "storageClient", new StorageClient(SMART_CARD_CACHE_CLIENT_KEY, {
-    storageEngine: 'sessionStorage'
-  }));
-  /**
-   * Retrieves the entire cache object from storage
-   * @returns The entire cache object
-   */
-  _defineProperty(this, "getCache", function () {
-    var stored = _this.storageClient.getItem(SMART_CARD_CACHE_KEY, {
-      useExpiredItem: true
+/**
+ * Singleton cache client for smart link responses. Uses sessionStorage for per-tab isolation (no cross-tab conflicts).
+ * If switching to localStorage for cross-tab sharing, add a 'storage' event listener in the constructor to sync
+ * memoryCache when other tabs modify the cache, preventing race conditions from concurrent writes.
+ */
+export var SmartCardLocalCacheClient = /*#__PURE__*/function () {
+  function SmartCardLocalCacheClient() {
+    var _this = this;
+    var maxItems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SMART_CARD_CACHE_DEFAULT_MAX_ITEMS;
+    _classCallCheck(this, SmartCardLocalCacheClient);
+    _defineProperty(this, "storageClient", new StorageClient(SMART_CARD_CACHE_CLIENT_KEY, {
+      storageEngine: 'sessionStorage'
+    }));
+    _defineProperty(this, "pendingWrite", false);
+    /**
+     * Retrieves the entire cache object from memory
+     * @returns The entire cache object
+     */
+    _defineProperty(this, "getCache", function () {
+      return _this.memoryCache;
     });
-    var persistentCache = stored ? JSON.parse(stored) : {};
-    return persistentCache;
-  });
-  /**
-   * Caches the SmartLinkResponse against the provided url in storage
-   * @param url The url (key) to store the response against
-   * @param response The SmartLinkResponse to be cached in storage
-   */
-  _defineProperty(this, "setItem", function (url, response) {
-    var newCache = _this.getCache();
+    /**
+     * Caches the SmartLinkResponse against the provided url in storage
+     * @param url The url (key) to store the response against
+     * @param response The SmartLinkResponse to be cached in storage
+     */
+    _defineProperty(this, "setItem", function (url, response) {
+      // Add or update the item in the cache with current timestamp
+      _this.memoryCache[url] = {
+        data: response,
+        timestamp: Date.now()
+      };
 
-    // Add or update the item in the cache with current timestamp
-    newCache[url] = {
-      data: response,
-      timestamp: Date.now()
-    };
+      // Apply FIFO behavior if cache exceeds maxItems
+      var cacheKeys = Object.keys(_this.memoryCache);
+      if (cacheKeys.length > _this.maxItems) {
+        // Sort keys by timestamp (oldest first) and remove the oldest items
+        var sortedKeys = cacheKeys.sort(function (a, b) {
+          return _this.memoryCache[a].timestamp - _this.memoryCache[b].timestamp;
+        });
+        var itemsToRemove = cacheKeys.length - _this.maxItems;
+        var keysToRemove = sortedKeys.slice(0, itemsToRemove);
+        keysToRemove.forEach(function (key) {
+          delete _this.memoryCache[key];
+        });
+      }
+
+      // Write through to storage asynchronously (non-blocking)
+      // Debounced to batch multiple rapid calls into a single write
+      if (!_this.pendingWrite) {
+        _this.pendingWrite = true;
+        queueMicrotask(function () {
+          try {
+            _this.storageClient.setItemWithExpiry(SMART_CARD_CACHE_KEY, JSON.stringify(_this.memoryCache));
+          } catch (_) {
+            // Ignore storage write errors (e.g. quota exceeded) to prevent blocking future writes
+            // Cache will still function in-memory for the session, but won't persist
+          } finally {
+            _this.pendingWrite = false;
+          }
+        });
+      }
+    });
+    /**
+     * Retrieves the cached SmartLinkResponse for the provided url from storage (if it exists)
+     * @param url The url (key) to retrieve the cached response for
+     * @returns The cached SmartLinkResponse if it exists, else undefined
+     */
+    _defineProperty(this, "getItem", function (url) {
+      var _this$memoryCache;
+      if (!url) {
+        return;
+      }
+      var response = (_this$memoryCache = _this.memoryCache) === null || _this$memoryCache === void 0 || (_this$memoryCache = _this$memoryCache[url]) === null || _this$memoryCache === void 0 ? void 0 : _this$memoryCache.data;
+      return response;
+    });
+    /**
+     * Checks if a cached entry exists for the provided url in storage
+     * @param url The url (key) to check for existence in the cache
+     * @returns True if a cached entry exists, else false
+     */
+    _defineProperty(this, "isUrlInCache", function (url) {
+      return url in _this.memoryCache;
+    });
+    this.maxItems = maxItems;
+    // Load cache from storage into memory on instantiation
+    var stored = this.storageClient.getItem(SMART_CARD_CACHE_KEY, {
+      useExpiredItem: true
+    });
+    this.memoryCache = stored ? JSON.parse(stored) : {};
+  }
 
-    // Apply FIFO behavior if cache exceeds maxItems
-    var cacheKeys = Object.keys(newCache);
-    if (cacheKeys.length > _this.maxItems) {
-      // Sort keys by timestamp (oldest first) and remove the oldest items
-      var sortedKeys = cacheKeys.sort(function (a, b) {
-        return newCache[a].timestamp - newCache[b].timestamp;
-      });
-      var itemsToRemove = cacheKeys.length - _this.maxItems;
-      var keysToRemove = sortedKeys.slice(0, itemsToRemove);
-      keysToRemove.forEach(function (key) {
-        delete newCache[key];
-      });
-    }
-    _this.storageClient.setItemWithExpiry(SMART_CARD_CACHE_KEY, JSON.stringify(newCache));
-  });
   /**
-   * Retrieves the cached SmartLinkResponse for the provided url from storage (if it exists)
-   * @param url The url (key) to retrieve the cached response for
-   * @returns The cached SmartLinkResponse if it exists, else undefined
+   * Gets the singleton instance of SmartCardLocalCacheClient.
+   * This ensures all callers share the same in-memory cache and prevents
+   * race conditions when multiple instances write to the same storage key.
+   * @param maxItems Maximum number of items to store in the cache (only used on first instantiation)
+   * @returns The singleton instance
    */
-  _defineProperty(this, "getItem", function (url) {
-    var _persistentCache$url;
-    if (!url) {
-      return;
+  return _createClass(SmartCardLocalCacheClient, null, [{
+    key: "getInstance",
+    value: function getInstance() {
+      var maxItems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SMART_CARD_CACHE_DEFAULT_MAX_ITEMS;
+      if (!SmartCardLocalCacheClient.instance) {
+        SmartCardLocalCacheClient.instance = new SmartCardLocalCacheClient(maxItems);
+      }
+      return SmartCardLocalCacheClient.instance;
     }
-    var persistentCache = _this.getCache();
-    var response = persistentCache === null || persistentCache === void 0 || (_persistentCache$url = persistentCache[url]) === null || _persistentCache$url === void 0 ? void 0 : _persistentCache$url.data;
-    return response;
-  });
-  /**
-   * Checks if a cached entry exists for the provided url in storage
-   * @param url The url (key) to check for existence in the cache
-   * @returns True if a cached entry exists, else false
-   */
-  _defineProperty(this, "isUrlInCache", function (url) {
-    var persistentCache = _this.getCache();
-    return persistentCache ? url in persistentCache : false;
-  });
-  this.maxItems = maxItems;
-});
+
+    /**
+     * Resets the singleton instance. Only intended for testing purposes.
+     * @internal
+     */
+  }, {
+    key: "resetInstance",
+    value: function resetInstance() {
+      SmartCardLocalCacheClient.instance = null;
+    }
+  }]);
+}();
+_defineProperty(SmartCardLocalCacheClient, "instance", null);

package/dist/types/smart-card-local-cache-client.d.ts

@@ -3,12 +3,33 @@ type CacheEntry = {
     data: SmartLinkResponse;
     timestamp: number;
 };
+/**
+ * Singleton cache client for smart link responses. Uses sessionStorage for per-tab isolation (no cross-tab conflicts).
+ * If switching to localStorage for cross-tab sharing, add a 'storage' event listener in the constructor to sync
+ * memoryCache when other tabs modify the cache, preventing race conditions from concurrent writes.
+ */
 export declare class SmartCardLocalCacheClient {
+    private static instance;
     private readonly storageClient;
     private maxItems;
-    constructor(maxItems?: number);
+    private memoryCache;
+    private pendingWrite;
+    private constructor();
     /**
-     * Retrieves the entire cache object from storage
+     * Gets the singleton instance of SmartCardLocalCacheClient.
+     * This ensures all callers share the same in-memory cache and prevents
+     * race conditions when multiple instances write to the same storage key.
+     * @param maxItems Maximum number of items to store in the cache (only used on first instantiation)
+     * @returns The singleton instance
+     */
+    static getInstance(maxItems?: number): SmartCardLocalCacheClient;
+    /**
+     * Resets the singleton instance. Only intended for testing purposes.
+     * @internal
+     */
+    static resetInstance(): void;
+    /**
+     * Retrieves the entire cache object from memory
      * @returns The entire cache object
      */
     getCache: () => Record<string, CacheEntry>;

package/dist/types-ts4.5/smart-card-local-cache-client.d.ts

@@ -3,12 +3,33 @@ type CacheEntry = {
     data: SmartLinkResponse;
     timestamp: number;
 };
+/**
+ * Singleton cache client for smart link responses. Uses sessionStorage for per-tab isolation (no cross-tab conflicts).
+ * If switching to localStorage for cross-tab sharing, add a 'storage' event listener in the constructor to sync
+ * memoryCache when other tabs modify the cache, preventing race conditions from concurrent writes.
+ */
 export declare class SmartCardLocalCacheClient {
+    private static instance;
     private readonly storageClient;
     private maxItems;
-    constructor(maxItems?: number);
+    private memoryCache;
+    private pendingWrite;
+    private constructor();
     /**
-     * Retrieves the entire cache object from storage
+     * Gets the singleton instance of SmartCardLocalCacheClient.
+     * This ensures all callers share the same in-memory cache and prevents
+     * race conditions when multiple instances write to the same storage key.
+     * @param maxItems Maximum number of items to store in the cache (only used on first instantiation)
+     * @returns The singleton instance
+     */
+    static getInstance(maxItems?: number): SmartCardLocalCacheClient;
+    /**
+     * Resets the singleton instance. Only intended for testing purposes.
+     * @internal
+     */
+    static resetInstance(): void;
+    /**
+     * Retrieves the entire cache object from memory
      * @returns The entire cache object
      */
     getCache: () => Record<string, CacheEntry>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-card-provider",
-	"version": "6.4.8",
+	"version": "6.4.9",
 	"description": "Contains the EditorCardProvider, for determining smart card behaviour in the editor.",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -39,7 +39,7 @@
 		"@atlaskit/linking-types": "^14.2.0",
 		"@atlaskit/node-data-provider": "^8.3.0",
 		"@atlaskit/platform-feature-flags": "^1.1.0",
-		"@atlaskit/tmp-editor-statsig": "^29.0.0",
+		"@atlaskit/tmp-editor-statsig": "^29.2.0",
 		"@babel/runtime": "^7.0.0",
 		"dataloader": "^2.1.0"
 	},