@atlaskit/editor-synced-block-provider 3.30.2 → 3.30.4

package/dist/cjs/utils/relayResponseConverter.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertParsedDataToSyncBlockInstance = convertParsedDataToSyncBlockInstance;
+exports.convertRelayResponseToSyncBlockInstance = convertRelayResponseToSyncBlockInstance;
+var _sharedSubscriptionUtils = require("../clients/block-service/sharedSubscriptionUtils");
+var _validValue = require("./validValue");
+/**
+ * Converts parsed subscription data to SyncBlockInstance format.
+ *
+ * @param parsed - The parsed subscription data
+ * @param resourceId - The resource ID for the block
+ * @returns A SyncBlockInstance
+ */
+function convertParsedDataToSyncBlockInstance(parsed, resourceId) {
+  return {
+    data: {
+      content: parsed.content,
+      contentUpdatedAt: parsed.contentUpdatedAt,
+      resourceId: parsed.blockAri,
+      blockInstanceId: parsed.blockInstanceId,
+      sourceAri: parsed.sourceAri,
+      product: parsed.product,
+      createdAt: parsed.createdAt,
+      createdBy: parsed.createdBy,
+      status: (0, _validValue.normaliseSyncBlockStatus)(parsed.status)
+    },
+    resourceId: resourceId
+  };
+}
+
+/**
+ * Converts a Relay subscription response to SyncBlockInstance format using shared parsing logic.
+
+ * @param response - The Relay subscription response containing block update data
+ * @param resourceId - The resource ID for the block
+ * @returns A SyncBlockInstance or null if parsing fails
+ * 
+ * @example
+ * ```typescript
+ * // In a Relay subscription handler
+ * onNext: (response) => {
+ *   if (response?.blockService_onBlockUpdated) {
+ *     const syncBlockInstance = convertRelayResponseToSyncBlockInstance(
+ *       response.blockService_onBlockUpdated,
+ *       resourceId,
+ *     );
+ *     if (syncBlockInstance) {
+ *       onUpdate(syncBlockInstance);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+function convertRelayResponseToSyncBlockInstance(response, resourceId) {
+  var _response$contentUpda, _response$deletionRea;
+  var payload = {
+    blockAri: response.blockAri,
+    blockInstanceId: response.blockInstanceId,
+    content: response.content,
+    contentUpdatedAt: (_response$contentUpda = response.contentUpdatedAt) !== null && _response$contentUpda !== void 0 ? _response$contentUpda : undefined,
+    createdAt: response.createdAt,
+    createdBy: response.createdBy,
+    deletionReason: (_response$deletionRea = response.deletionReason) !== null && _response$deletionRea !== void 0 ? _response$deletionRea : undefined,
+    product: response.product,
+    sourceAri: response.sourceAri,
+    status: response.status
+  };
+  var parsed = (0, _sharedSubscriptionUtils.parseSubscriptionPayload)(payload);
+  if (!parsed) {
+    return null;
+  }
+  return convertParsedDataToSyncBlockInstance(parsed, resourceId);
+}

package/dist/cjs/utils/relaySubscriptionUtils.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRelayBlockSubscription = createRelayBlockSubscription;
+exports.createRelaySubscriptionFunction = createRelaySubscriptionFunction;
+var _relayRuntime = require("relay-runtime");
+var _ari = require("../clients/block-service/ari");
+var _blockSubscription = require("../clients/block-service/blockSubscription");
+var _relaySubscriptionUtilsSubscription = _interopRequireDefault(require("./__generated__/relaySubscriptionUtilsSubscription.graphql"));
+var _relayResponseConverter = require("./relayResponseConverter");
+/**
+ * Configuration for creating a Relay block subscription.
+ */
+
+/**
+ * Creates a Relay-based block subscription without needing to wrap providers.
+ * This is a clean utility function that can be used directly in components or hooks.
+ * 
+ * @param config - Configuration for the subscription
+ * @returns An unsubscribe function to dispose the subscription
+ * 
+ * @example
+ * ```typescript
+ * const unsubscribe = createRelayBlockSubscription({
+ *   relayEnvironment: environment,
+ *   cloudId: 'my-cloud-id',
+ *   resourceId: 'my-resource-id',
+ *   onUpdate: (blockInstance) => {
+ *     console.log('Block updated:', blockInstance);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Subscription error:', error);
+ *   }
+ * });
+ * 
+ * // Later, when component unmounts or subscription is no longer needed
+ * unsubscribe();
+ * ```
+ */
+function createRelayBlockSubscription(config) {
+  var relayEnvironment = config.relayEnvironment,
+    cloudId = config.cloudId,
+    resourceId = config.resourceId,
+    onUpdate = config.onUpdate,
+    _onError = config.onError;
+
+  // Convert resourceId to blockAri for the subscription
+  var blockAri = (0, _ari.generateBlockAriFromReference)({
+    cloudId: cloudId,
+    resourceId: resourceId
+  });
+  var subscriptionQuery = _relaySubscriptionUtilsSubscription.default;
+
+  // Try to use Relay subscription first
+  try {
+    var disposable = (0, _relayRuntime.requestSubscription)(relayEnvironment, {
+      subscription: subscriptionQuery,
+      variables: {
+        resourceId: blockAri
+      },
+      onNext: function onNext(response) {
+        if (response !== null && response !== void 0 && response.blockService_onBlockUpdated) {
+          var syncBlockInstance = (0, _relayResponseConverter.convertRelayResponseToSyncBlockInstance)(response.blockService_onBlockUpdated, resourceId);
+          if (syncBlockInstance) {
+            onUpdate(syncBlockInstance);
+          } else {
+            _onError === null || _onError === void 0 || _onError(new Error('Failed to parse Relay block subscription payload'));
+          }
+        }
+      },
+      onError: function onError(error) {
+        _onError === null || _onError === void 0 || _onError(error);
+      }
+    });
+
+    // If subscription was successfully created, return the unsubscribe function
+    if (disposable) {
+      return function () {
+        disposable.dispose();
+      };
+    }
+  } catch (error) {
+    // If requestSubscription throws, fall back to WebSocket
+    _onError === null || _onError === void 0 || _onError(error instanceof Error ? error : new Error('Relay subscription failed'));
+  }
+
+  // Fallback to WebSocket subscription when Relay subscriptions aren't available
+  return (0, _blockSubscription.subscribeToBlockUpdates)(blockAri, function (parsedData) {
+    var syncBlockInstance = (0, _relayResponseConverter.convertParsedDataToSyncBlockInstance)(parsedData, parsedData.resourceId);
+    onUpdate(syncBlockInstance);
+  }, function (error) {
+    _onError === null || _onError === void 0 || _onError(error);
+  });
+}
+
+/**
+ * Hook-like function to create a subscription function that can be passed to providers.
+ * This creates a function with the same signature as subscribeToBlockUpdates that uses Relay.
+ * 
+ * @param cloudId - Cloud ID for generating block ARIs  
+ * @param relayEnvironment - Optional Relay environment. If not provided, will attempt to use global environment
+ * @returns A function that can be used as subscribeToBlockUpdates in provider configurations
+ * 
+ * @example
+ * ```typescript
+ * const relaySubscribeToBlockUpdates = createRelaySubscriptionFunction(cloudId, environment);
+ * 
+ * // Can be used directly as a subscribeToBlockUpdates replacement
+ * const unsubscribe = relaySubscribeToBlockUpdates(resourceId, onUpdate, onError);
+ * ```
+ */
+function createRelaySubscriptionFunction(cloudId, relayEnvironment) {
+  return function (resourceId, onUpdate, onError) {
+    var environment = relayEnvironment;
+    if (!environment) {
+      onError === null || onError === void 0 || onError(new Error('Relay environment not available'));
+      return function () {};
+    }
+    return createRelayBlockSubscription({
+      relayEnvironment: environment,
+      cloudId: cloudId,
+      resourceId: resourceId,
+      onUpdate: onUpdate,
+      onError: onError
+    });
+  };
+}

package/dist/es2019/clients/block-service/blockSubscription.js

@@ -1,6 +1,6 @@
 import { createClient } from 'graphql-ws';
 import { isSSR } from '@atlaskit/editor-common/core-utils';
-import { convertContentUpdatedAt } from '../../utils/utils';
+import { BLOCK_SERVICE_SUBSCRIPTION_QUERY, parseSubscriptionPayload } from './sharedSubscriptionUtils';
 const GRAPHQL_WS_ENDPOINT = '/gateway/api/graphql/subscriptions';
 let blockServiceClient = null;
 const getBlockServiceClient = () => {
@@ -19,71 +19,6 @@ const getBlockServiceClient = () => {
   }
   return blockServiceClient;
 };
-const SUBSCRIPTION_QUERY = `
-subscription EDITOR_SYNCED_BLOCK_ON_BLOCK_UPDATED($resourceId: ID!) {
-	blockService_onBlockUpdated(resourceId: $resourceId) {
-		blockAri
-		blockInstanceId
-		content
-		contentUpdatedAt
-		createdAt
-		createdBy
-		deletionReason
-		product
-		sourceAri
-		status
-	}
-}
-`;
-/**
- * Extracts the resourceId from a block ARI.
- * Block ARI format: ari:cloud:blocks:<cloudId>:synced-block/<resourceId>
- * @param blockAri - The block ARI string
- * @returns The resourceId portion of the ARI
- */
-const extractResourceIdFromBlockAri = blockAri => {
-  // eslint-disable-next-line require-unicode-regexp
-  const match = blockAri.match(/ari:cloud:blocks:[^:]+:synced-block\/(.+)$/);
-  return (match === null || match === void 0 ? void 0 : match[1]) || null;
-};
-
-/**
- * Parses the subscription payload into a standardized format.
- * @param payload - The raw subscription payload
- * @returns Parsed block data or null if parsing fails
- */
-const parseSubscriptionPayload = payload => {
-  try {
-    const resourceId = extractResourceIdFromBlockAri(payload.blockAri);
-    if (!resourceId) {
-      return null;
-    }
-    let createdAt;
-    if (payload.createdAt !== undefined && payload.createdAt !== null) {
-      try {
-        // BE returns microseconds, convert to milliseconds
-        createdAt = new Date(payload.createdAt / 1000).toISOString();
-      } catch {
-        createdAt = undefined;
-      }
-    }
-    return {
-      blockAri: payload.blockAri,
-      blockInstanceId: payload.blockInstanceId,
-      content: JSON.parse(payload.content),
-      contentUpdatedAt: convertContentUpdatedAt(payload.contentUpdatedAt),
-      createdAt,
-      createdBy: payload.createdBy,
-      product: payload.product,
-      resourceId,
-      sourceAri: payload.sourceAri,
-      status: payload.status
-    };
-  } catch {
-    return null;
-  }
-};
-
 /**
  * Creates a GraphQL subscription to block updates using the shared graphql-ws client.
  *
@@ -99,7 +34,7 @@ export const subscribeToBlockUpdates = (blockAri, onData, onError) => {
     return () => {};
   }
   const unsubscribe = client.subscribe({
-    query: SUBSCRIPTION_QUERY,
+    query: BLOCK_SERVICE_SUBSCRIPTION_QUERY,
     variables: {
       resourceId: blockAri
     },

package/dist/es2019/clients/block-service/sharedSubscriptionUtils.js

@@ -0,0 +1,91 @@
+import { convertContentUpdatedAt } from '../../utils/utils';
+/**
+ * Shared GraphQL subscription query for block updates.
+ * This is the canonical subscription query used across all implementations.
+ */
+export const BLOCK_SERVICE_SUBSCRIPTION_QUERY = `
+subscription EDITOR_SYNCED_BLOCK_ON_BLOCK_UPDATED($resourceId: ID!) {
+	blockService_onBlockUpdated(resourceId: $resourceId) {
+		blockAri
+		blockInstanceId
+		content
+		contentUpdatedAt
+		createdAt
+		createdBy
+		deletionReason
+		product
+		sourceAri
+		status
+	}
+}
+`;
+
+/**
+ * Raw subscription payload from the GraphQL subscription.
+ * This represents the exact shape returned by the blockService_onBlockUpdated subscription.
+ */
+
+/**
+ * Parsed and normalized block subscription data.
+ * This is the standardized format used across different subscription implementations.
+ */
+
+/**
+ * Extracts the resourceId from a block ARI.
+ * Block ARI format: ari:cloud:blocks:<cloudId>:synced-block/<resourceId>
+ * @param blockAri - The block ARI string
+ * @returns The resourceId portion of the ARI
+ */
+export const extractResourceIdFromBlockAri = blockAri => {
+  // eslint-disable-next-line require-unicode-regexp
+  const match = blockAri.match(/ari:cloud:blocks:[^:]+:synced-block\/(.+)$/);
+  return (match === null || match === void 0 ? void 0 : match[1]) || null;
+};
+
+/**
+ * Converts a timestamp to ISO string.
+ * @param timestamp - Timestamp in milliseconds
+ * @returns ISO string or undefined if conversion fails
+ */
+export const convertTimestampToISOString = timestamp => {
+  if (timestamp === undefined || timestamp === null) {
+    return undefined;
+  }
+  try {
+    return new Date(timestamp).toISOString();
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Parses the raw subscription payload into a standardized format.
+ * This function handles all the data transformation and error handling consistently
+ * across different subscription implementations.
+ * 
+ * @param payload - The raw subscription payload
+ * @returns Parsed block data or null if parsing fails
+ */
+export const parseSubscriptionPayload = payload => {
+  try {
+    const resourceId = extractResourceIdFromBlockAri(payload.blockAri);
+    if (!resourceId) {
+      return null;
+    }
+    const createdAt = convertTimestampToISOString(payload.createdAt);
+    return {
+      blockAri: payload.blockAri,
+      blockInstanceId: payload.blockInstanceId,
+      content: JSON.parse(payload.content),
+      contentUpdatedAt: convertContentUpdatedAt(payload.contentUpdatedAt),
+      createdAt,
+      createdBy: payload.createdBy,
+      product: payload.product,
+      resourceId,
+      sourceAri: payload.sourceAri,
+      status: payload.status
+    };
+  } catch {
+    return null;
+  }
+};

package/dist/es2019/index.js

@@ -21,9 +21,14 @@ export { fetchConfluencePageInfo } from './clients/confluence/sourceInfo';
 export { SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
 // store managers
 export { ReferenceSyncBlockStoreManager } from './store-manager/referenceSyncBlockStoreManager';
+export { SyncBlockInMemorySessionCache, syncBlockInMemorySessionCache } from './store-manager/syncBlockInMemorySessionCache';
 export { SyncBlockStoreManager, useMemoizedSyncBlockStoreManager } from './store-manager/syncBlockStoreManager';
 
 // utils
+export { BLOCK_SERVICE_SUBSCRIPTION_QUERY } from './clients/block-service/sharedSubscriptionUtils';
+export { parseSubscriptionPayload } from './clients/block-service/sharedSubscriptionUtils';
+export { convertRelayResponseToSyncBlockInstance } from './utils/relayResponseConverter';
+export { createRelayBlockSubscription, createRelaySubscriptionFunction } from './utils/relaySubscriptionUtils';
 export { resolveSyncBlockInstance } from './utils/resolveSyncBlockInstance';
 export { parseResourceId, createResourceIdForReference } from './utils/resourceId';
 export { createSyncBlockNode, convertSyncBlockPMNodeToSyncBlockData, convertSyncBlockJSONNodeToSyncBlockNode, convertPMNodesToSyncBlockNodes, getContentIdAndProductFromResourceId } from './utils/utils';

package/dist/es2019/providers/block-service/blockServiceAPI.js

@@ -6,6 +6,7 @@ import { batchRetrieveSyncedBlocks, BlockError, createSyncedBlock, deleteSyncedB
 import { subscribeToBlockUpdates as subscribeToBlockUpdatesWS } from '../../clients/block-service/blockSubscription';
 import { SyncBlockError } from '../../common/types';
 import { stringifyError } from '../../utils/errorHandling';
+import { createRelaySubscriptionFunction } from '../../utils/relaySubscriptionUtils';
 import { createResourceIdForReference } from '../../utils/resourceId';
 import { convertContentUpdatedAt } from '../../utils/utils';
 const mapBlockError = error => {
@@ -313,10 +314,12 @@ export const batchFetchData = async (cloudId, parentAri, blockNodeIdentifiers) =
 class BlockServiceADFFetchProvider {
   constructor({
     cloudId,
-    parentAri
+    parentAri,
+    relayEnvironment
   }) {
     this.cloudId = cloudId;
     this.parentAri = parentAri;
+    this.relayEnvironment = relayEnvironment;
   }
 
   // resourceId of the reference synced block.
@@ -442,6 +445,7 @@ class BlockServiceADFFetchProvider {
 
   /**
    * Subscribes to real-time updates for a specific block using GraphQL WebSocket subscriptions.
+   * If a Relay environment is provided, uses Relay subscriptions; otherwise falls back to WebSocket.
    * @param resourceId - The resource ID of the block to subscribe to
    * @param onUpdate - Callback function invoked when the block is updated
    * @param onError - Optional callback function invoked on subscription errors
@@ -452,6 +456,14 @@ class BlockServiceADFFetchProvider {
       cloudId: this.cloudId,
       resourceId
     });
+
+    // If Relay environment is available, use Relay subscriptions
+    if (this.relayEnvironment && fg('platform_synced_block_patch_3')) {
+      const relaySubscribeToBlockUpdates = createRelaySubscriptionFunction(this.cloudId, this.relayEnvironment);
+      return relaySubscribeToBlockUpdates(resourceId, onUpdate, onError);
+    }
+
+    // Fall back to WebSocket subscriptions
     return subscribeToBlockUpdatesWS(blockAri, parsedData => {
       // Convert ParsedBlockSubscriptionData to SyncBlockInstance
       const syncBlockInstance = {
@@ -672,12 +684,14 @@ const createBlockServiceAPIProviders = ({
   parentAri,
   parentId,
   product,
-  getVersion
+  getVersion,
+  relayEnvironment
 }) => {
   return {
     fetchProvider: new BlockServiceADFFetchProvider({
       cloudId,
-      parentAri
+      parentAri,
+      relayEnvironment
     }),
     writeProvider: new BlockServiceADFWriteProvider({
       cloudId,
@@ -693,7 +707,8 @@ export const useMemoizedBlockServiceAPIProviders = ({
   parentAri,
   parentId,
   product,
-  getVersion
+  getVersion,
+  relayEnvironment
 }) => {
   return useMemo(() => {
     return createBlockServiceAPIProviders({
@@ -701,9 +716,10 @@ export const useMemoizedBlockServiceAPIProviders = ({
       parentAri,
       parentId,
       product,
-      getVersion
+      getVersion,
+      relayEnvironment
     });
-  }, [cloudId, parentAri, parentId, product, getVersion]);
+  }, [cloudId, parentAri, parentId, product, getVersion, relayEnvironment]);
 };
 const createBlockServiceFetchOnlyAPIProvider = ({
   cloudId,

package/dist/es2019/store-manager/referenceSyncBlockStoreManager.js

@@ -10,7 +10,8 @@ import { getFetchExperience, getFetchSourceInfoExperience, getSaveReferenceExper
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 import { parseResourceId } from '../utils/resourceId';
 import { createSyncBlockNode } from '../utils/utils';
-const SESSION_STORAGE_KEY_PREFIX = 'sync-block-data-';
+import { syncBlockInMemorySessionCache } from './syncBlockInMemorySessionCache';
+const CACHE_KEY_PREFIX = 'sync-block-data-';
 
 // A store manager responsible for the lifecycle and state management of reference sync blocks in an editor instance.
 // Designed to manage local in-memory state and synchronize with an external data provider.
@@ -66,8 +67,8 @@ export class ReferenceSyncBlockStoreManager {
     this.subscriptionChangeListeners = new Set();
     this.newlyAddedSyncBlocks = new Set();
 
-    // The provider might have SSR data cache already set, so we need to update the cache in session storage
-    this.setSSRDataInSessionStorage((_this$dataProvider = this.dataProvider) === null || _this$dataProvider === void 0 ? void 0 : _this$dataProvider.getNodeDataCacheKeys());
+    // The provider might have SSR data cache already set, so we need to update the cache in session memory storage
+    this.setSSRDataInSessionCache((_this$dataProvider = this.dataProvider) === null || _this$dataProvider === void 0 ? void 0 : _this$dataProvider.getNodeDataCacheKeys());
   }
 
   /**
@@ -180,48 +181,28 @@ export class ReferenceSyncBlockStoreManager {
   getInitialSyncBlockData(resourceId) {
     var _this$dataProvider2, _this$dataProvider2$g;
     const syncBlockNode = createSyncBlockNode('', resourceId);
-    const data = (_this$dataProvider2 = this.dataProvider) === null || _this$dataProvider2 === void 0 ? void 0 : (_this$dataProvider2$g = _this$dataProvider2.getNodeDataFromCache(syncBlockNode)) === null || _this$dataProvider2$g === void 0 ? void 0 : _this$dataProvider2$g.data;
-    if (data) {
-      return data;
+    const providerData = (_this$dataProvider2 = this.dataProvider) === null || _this$dataProvider2 === void 0 ? void 0 : (_this$dataProvider2$g = _this$dataProvider2.getNodeDataFromCache(syncBlockNode)) === null || _this$dataProvider2$g === void 0 ? void 0 : _this$dataProvider2$g.data;
+    if (providerData) {
+      return providerData;
     }
-    if (fg('platform_synced_block_patch_3')) {
-      const sessionData = this.getSyncBlockDataFromSessionStorage(resourceId);
-      if (sessionData) {
-        return sessionData;
-      }
-    }
-    return undefined;
+    return this.getFromSessionCache(resourceId);
   }
-  updateCacheInSessionStorage(resourceId) {
-    try {
-      const latestData = this.getFromCache(resourceId);
-      if (latestData) {
-        sessionStorage.setItem(`${SESSION_STORAGE_KEY_PREFIX}${resourceId}`, JSON.stringify(latestData));
-      }
-    } catch (error) {
-      logException(error, {
-        location: 'editor-synced-block-provider/referenceSyncBlockStoreManager/updateCacheInSessionStorage'
-      });
+  updateSessionCache(resourceId) {
+    const latestData = this.getFromCache(resourceId);
+    if (latestData) {
+      syncBlockInMemorySessionCache.setItem(`${CACHE_KEY_PREFIX}${resourceId}`, JSON.stringify(latestData));
     }
   }
-  getSyncBlockDataFromSessionStorage(resourceId) {
-    let sessionData = null;
-    try {
-      sessionData = sessionStorage.getItem(`${SESSION_STORAGE_KEY_PREFIX}${resourceId}`);
-    } catch (error) {
-      logException(error, {
-        location: 'editor-synced-block-provider/referenceSyncBlockStoreManager/getSyncBlockDataFromSessionStorage'
-      });
-      return undefined;
-    }
-    if (!sessionData) {
-      return undefined;
-    }
+  getFromSessionCache(resourceId) {
     try {
-      return JSON.parse(sessionData);
+      const raw = syncBlockInMemorySessionCache.getItem(`${CACHE_KEY_PREFIX}${resourceId}`);
+      if (!raw) {
+        return undefined;
+      }
+      return JSON.parse(raw);
     } catch (error) {
       logException(error, {
-        location: 'editor-synced-block-provider/referenceSyncBlockStoreManager/getSyncBlockDataFromSessionStorage'
+        location: 'editor-synced-block-provider/referenceSyncBlockStoreManager/getFromSessionCache'
       });
       return undefined;
     }
@@ -655,7 +636,7 @@ export class ReferenceSyncBlockStoreManager {
         });
       }
       if (fg('platform_synced_block_patch_3')) {
-        this.updateCacheInSessionStorage(resourceId);
+        this.updateSessionCache(resourceId);
       }
     }
   }
@@ -691,12 +672,12 @@ export class ReferenceSyncBlockStoreManager {
       this.scheduledBatchFetch();
     }
   }
-  setSSRDataInSessionStorage(resourceIds) {
+  setSSRDataInSessionCache(resourceIds) {
     if (!resourceIds || resourceIds.length === 0) {
       return;
     }
     resourceIds.forEach(resourceId => {
-      this.updateCacheInSessionStorage(resourceId);
+      this.updateSessionCache(resourceId);
     });
   }
   subscribeToSyncBlock(resourceId, localId, callback) {
@@ -727,8 +708,6 @@ export class ReferenceSyncBlockStoreManager {
       this.notifySubscriptionChangeListeners();
     }
     const syncBlockNode = createSyncBlockNode(localId, resourceId);
-
-    // call the callback immediately if we have cached data
     const cachedData = (_this$dataProvider7 = this.dataProvider) === null || _this$dataProvider7 === void 0 ? void 0 : (_this$dataProvider7$g = _this$dataProvider7.getNodeDataFromCache(syncBlockNode)) === null || _this$dataProvider7$g === void 0 ? void 0 : _this$dataProvider7$g.data;
     if (cachedData) {
       callback(cachedData);

package/dist/es2019/store-manager/syncBlockInMemorySessionCache.js

@@ -0,0 +1,57 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/**
+ * In-memory session cache for sync block data with size-based LRU eviction.
+ *
+ * Backed by a plain Map so that potentially private ADF content is never
+ * written to any browser-persistent storage (sessionStorage, localStorage,
+ * IndexedDB). The module-level singleton survives SPA transitions (no full
+ * page reload) and is naturally cleared on hard navigation or tab close.
+ *
+ * Uses JavaScript Map's insertion-order guarantee to implement LRU:
+ * on every read or write the accessed entry is moved to the end of the
+ * iteration order; when total cached size exceeds `maxSize`, the oldest
+ * (least-recently-used) entries are evicted first.
+ */
+export class SyncBlockInMemorySessionCache {
+  constructor(maxSize = 5 * 1024 * 1024) {
+    _defineProperty(this, "store", new Map());
+    _defineProperty(this, "currentSize", 0);
+    this.maxSize = maxSize;
+  }
+  getItem(key) {
+    const value = this.store.get(key);
+    if (value === undefined) {
+      return null;
+    }
+    this.store.delete(key);
+    this.store.set(key, value);
+    return value;
+  }
+  setItem(key, value) {
+    const existing = this.store.get(key);
+    if (existing !== undefined) {
+      this.currentSize -= existing.length;
+      this.store.delete(key);
+    }
+    this.store.set(key, value);
+    this.currentSize += value.length;
+    while (this.currentSize > this.maxSize && this.store.size > 1) {
+      const oldestKey = this.store.keys().next().value;
+      if (oldestKey !== undefined) {
+        const oldestValue = this.store.get(oldestKey);
+        if (oldestValue !== undefined) {
+          this.currentSize -= oldestValue.length;
+        }
+        this.store.delete(oldestKey);
+      }
+    }
+  }
+  removeItem(key) {
+    const value = this.store.get(key);
+    if (value !== undefined) {
+      this.currentSize -= value.length;
+      this.store.delete(key);
+    }
+  }
+}
+export const syncBlockInMemorySessionCache = new SyncBlockInMemorySessionCache();