@atlaskit/editor-synced-block-provider 3.30.5 → 3.31.0

package/dist/es2019/hooks/useFetchSyncBlockTitle.js

@@ -1,5 +1,7 @@
-import { useEffect, useState } from 'react';
-export const useFetchSyncBlockTitle = (manager, syncBlockNode) => {
+import { useEffect, useRef, useState } from 'react';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { conditionalHooksFactory } from '@atlaskit/platform-feature-flags-react';
+const useFetchSyncBlockTitleBase = (manager, syncBlockNode) => {
   // Initialize state from cache to prevent flickering during re-renders
   const [sourceTitle, setSourceTitle] = useState(() => {
     var _cachedData$data;
@@ -24,4 +26,35 @@ export const useFetchSyncBlockTitle = (manager, syncBlockNode) => {
     };
   }, [manager, syncBlockNode]);
   return sourceTitle;
-};
+};
+const useFetchSyncBlockTitlePatched = (manager, syncBlockNode) => {
+  var _syncBlockNode$attrs, _syncBlockNode$attrs2;
+  const nodeRef = useRef(syncBlockNode);
+  nodeRef.current = syncBlockNode;
+  const nodeTypeName = syncBlockNode.type.name;
+  const resourceId = (_syncBlockNode$attrs = syncBlockNode.attrs) === null || _syncBlockNode$attrs === void 0 ? void 0 : _syncBlockNode$attrs.resourceId;
+  const localId = (_syncBlockNode$attrs2 = syncBlockNode.attrs) === null || _syncBlockNode$attrs2 === void 0 ? void 0 : _syncBlockNode$attrs2.localId;
+
+  // Initialize state from cache to prevent flickering during re-renders
+  const [sourceTitle, setSourceTitle] = useState(() => {
+    var _cachedData$data2;
+    if (nodeTypeName !== 'syncBlock') {
+      return undefined;
+    }
+    if (!resourceId) {
+      return undefined;
+    }
+    const cachedData = manager.referenceManager.getFromCache(resourceId);
+    return cachedData === null || cachedData === void 0 ? void 0 : (_cachedData$data2 = cachedData.data) === null || _cachedData$data2 === void 0 ? void 0 : _cachedData$data2.sourceTitle;
+  });
+  useEffect(() => {
+    const unsubscribe = manager.referenceManager.subscribeToSourceTitle(nodeRef.current, title => {
+      setSourceTitle(title);
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [manager, nodeTypeName, resourceId, localId]);
+  return sourceTitle;
+};
+export const useFetchSyncBlockTitle = conditionalHooksFactory(() => fg('platform_synced_block_patch_4'), useFetchSyncBlockTitlePatched, useFetchSyncBlockTitleBase);

package/dist/es2019/hooks/useHandleContentChanges.js

@@ -1,5 +1,8 @@
 import { useEffect } from 'react';
 export const useHandleContentChanges = (manager, syncBlockNode) => {
+  // syncBlockNode is intentionally in deps — its reference changes when the
+  // node content is modified by a ProseMirror transaction, which is exactly
+  // when the source manager cache needs to be updated.
   useEffect(() => {
     manager.sourceManager.updateSyncBlockData(syncBlockNode);
   }, [manager, syncBlockNode]);

package/dist/es2019/index.js

@@ -10,13 +10,13 @@ export { useHandleContentChanges } from './hooks/useHandleContentChanges';
 
 // clients
 export { generateBlockAri, generateBlockAriFromReference, getLocalIdFromBlockResourceId } from './clients/block-service/ari';
-export { BlockError } from './clients/block-service/blockService';
+export { BlockError, updateSyncedBlocks } from './clients/block-service/blockService';
 export { getConfluencePageAri, getPageIdAndTypeFromConfluencePageAri } from './clients/confluence/ari';
 export { fetchMediaToken } from './clients/confluence/fetchMediaToken';
 export { getJiraWorkItemAri, getJiraWorkItemIdFromAri } from './clients/jira/ari';
 
 // providers
-export { useMemoizedBlockServiceAPIProviders, useMemoizedBlockServiceFetchOnlyAPIProvider, fetchReferences, batchFetchData, blockAriToResourceId, convertToSyncBlockData, extractResourceIdFromBlockAri } from './providers/block-service/blockServiceAPI';
+export { useMemoizedBlockServiceAPIProviders, useMemoizedBlockServiceFetchOnlyAPIProvider, fetchReferences, batchFetchData, writeDataBatch, blockAriToResourceId, convertToSyncBlockData, extractResourceIdFromBlockAri } from './providers/block-service/blockServiceAPI';
 export { fetchConfluencePageInfo } from './clients/confluence/sourceInfo';
 export { SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
 // store managers
@@ -25,10 +25,6 @@ export { SyncBlockInMemorySessionCache, syncBlockInMemorySessionCache } from './
 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

@@ -2,11 +2,10 @@
 import { useMemo } from 'react';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { generateBlockAri, generateBlockAriFromReference } from '../../clients/block-service/ari';
-import { batchRetrieveSyncedBlocks, BlockError, createSyncedBlock, deleteSyncedBlock, getReferenceSyncedBlocks, getReferenceSyncedBlocksByBlockAri, getSyncedBlockContent, updateReferenceSyncedBlockOnDocument, updateSyncedBlock } from '../../clients/block-service/blockService';
+import { batchRetrieveSyncedBlocks, BlockError, createSyncedBlock, deleteSyncedBlock, getReferenceSyncedBlocks, getReferenceSyncedBlocksByBlockAri, getSyncedBlockContent, updateReferenceSyncedBlockOnDocument, updateSyncedBlock, updateSyncedBlocks } from '../../clients/block-service/blockService';
 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 => {
@@ -308,18 +307,102 @@ export const batchFetchData = async (cloudId, parentAri, blockNodeIdentifiers) =
     }));
   }
 };
+
+/**
+ * Batch writes multiple synced blocks.
+ * @param cloudId - The cloudId of the block. E.G the cloudId of the confluence page, or the cloudId of the Jira instance
+ * @param parentAri - The ARI of the parent of the block. E.G the ARI of the confluence page, or the ARI of the Jira work item
+ * @param parentId - The parentId of the block. E.G the pageId for a confluence page, or the issueId for a Jira work item
+ * @param product - The product of the block. E.G 'confluence-page', 'jira-work-item'
+ * @param data - Array of SyncBlockData to write
+ * @param stepVersion - Optional version number
+ * @returns Array of WriteSyncBlockResult results
+ */
+export const writeDataBatch = async (cloudId, parentAri, parentId, product, data, stepVersion) => {
+  if (!parentAri || !parentId) {
+    return data.map(block => ({
+      error: SyncBlockError.Errored,
+      resourceId: block.resourceId
+    }));
+  }
+  try {
+    // Create a map from blockAri to original resourceId for matching responses
+    const blockAriToResourceIdMap = new Map();
+    const blocks = data.map(block => {
+      const blockAri = generateBlockAri({
+        cloudId,
+        parentId,
+        product,
+        resourceId: block.resourceId
+      });
+      blockAriToResourceIdMap.set(blockAri, block.resourceId);
+      return {
+        blockAri,
+        content: JSON.stringify(block.content),
+        status: block.status,
+        stepVersion
+      };
+    });
+    const response = await updateSyncedBlocks({
+      blocks
+    });
+    const results = [];
+
+    // Process successful updates
+    if (response.success) {
+      const successResourceIds = new Set(response.success.map(block => blockAriToResourceIdMap.get(block.blockAri)));
+      for (const block of data) {
+        if (successResourceIds.has(block.resourceId)) {
+          results.push({
+            resourceId: block.resourceId
+          });
+        }
+      }
+    }
+    if (response.error) {
+      const errorResourceIds = new Map(response.error.map(err => [
+      // Use the map to get the original resourceId
+      blockAriToResourceIdMap.get(err.blockAri) || '', mapErrorResponseCode(err.code)]));
+      for (const block of data) {
+        const error = errorResourceIds.get(block.resourceId);
+        if (error) {
+          results.push({
+            error,
+            resourceId: block.resourceId
+          });
+        } else if (!results.some(r => r.resourceId === block.resourceId)) {
+          // If not in success or error lists, mark as errored
+          results.push({
+            error: SyncBlockError.Errored,
+            resourceId: block.resourceId
+          });
+        }
+      }
+    }
+    return results;
+  } catch (error) {
+    if (error instanceof BlockError) {
+      return data.map(block => ({
+        error: mapBlockError(error),
+        resourceId: block.resourceId
+      }));
+    }
+    return data.map(block => ({
+      error: stringifyError(error),
+      resourceId: block.resourceId
+    }));
+  }
+};
 /**
  * ADFFetchProvider implementation that fetches synced block data from Block Service API
  */
 class BlockServiceADFFetchProvider {
   constructor({
     cloudId,
-    parentAri,
-    relayEnvironment
+    parentAri
   }) {
     this.cloudId = cloudId;
     this.parentAri = parentAri;
-    this.relayEnvironment = relayEnvironment;
   }
 
   // resourceId of the reference synced block.
@@ -445,7 +528,6 @@ 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
@@ -456,14 +538,6 @@ 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 = {
@@ -643,6 +717,14 @@ class BlockServiceADFWriteProvider {
   generateResourceId() {
     return crypto.randomUUID();
   }
+  generateBlockAri(resourceId) {
+    return generateBlockAri({
+      cloudId: this.cloudId,
+      parentId: this.parentId || '',
+      product: this.product,
+      resourceId
+    });
+  }
   async updateReferenceData(blocks, noContent) {
     if (!this.parentAri) {
       return {
@@ -678,20 +760,89 @@ class BlockServiceADFWriteProvider {
       };
     }
   }
+  async writeDataBatch(data) {
+    if (!this.parentAri || !this.parentId) {
+      return data.map(block => ({
+        error: SyncBlockError.Errored,
+        resourceId: block.resourceId
+      }));
+    }
+    const stepVersion = this.getVersion ? await this.getVersion() : undefined;
+    try {
+      // Create a map from blockAri to original resourceId for matching responses
+      const blockAriToResourceIdMap = new Map();
+      const blocks = data.map(block => {
+        const blockAri = this.generateBlockAri(block.resourceId);
+        blockAriToResourceIdMap.set(blockAri, block.resourceId);
+        return {
+          blockAri,
+          content: JSON.stringify(block.content),
+          status: block.status,
+          stepVersion
+        };
+      });
+      const response = await updateSyncedBlocks({
+        blocks
+      });
+      const results = [];
+
+      // Process successful updates
+      if (response.success) {
+        const successResourceIds = new Set(response.success.map(block => blockAriToResourceIdMap.get(block.blockAri)));
+        for (const block of data) {
+          if (successResourceIds.has(block.resourceId)) {
+            results.push({
+              resourceId: block.resourceId
+            });
+          }
+        }
+      }
+      if (response.error) {
+        const errorResourceIds = new Map(response.error.map(err => [
+        // Use the map to get the original resourceId
+        blockAriToResourceIdMap.get(err.blockAri) || '', mapErrorResponseCode(err.code)]));
+        for (const block of data) {
+          const error = errorResourceIds.get(block.resourceId);
+          if (error) {
+            results.push({
+              error,
+              resourceId: block.resourceId
+            });
+          } else if (!results.some(r => r.resourceId === block.resourceId)) {
+            // If not in success or error lists, mark as errored
+            results.push({
+              error: SyncBlockError.Errored,
+              resourceId: block.resourceId
+            });
+          }
+        }
+      }
+      return results;
+    } catch (error) {
+      if (error instanceof BlockError) {
+        return data.map(block => ({
+          error: mapBlockError(error),
+          resourceId: block.resourceId
+        }));
+      }
+      return data.map(block => ({
+        error: stringifyError(error),
+        resourceId: block.resourceId
+      }));
+    }
+  }
 }
 const createBlockServiceAPIProviders = ({
   cloudId,
   parentAri,
   parentId,
   product,
-  getVersion,
-  relayEnvironment
+  getVersion
 }) => {
   return {
     fetchProvider: new BlockServiceADFFetchProvider({
       cloudId,
-      parentAri,
-      relayEnvironment
+      parentAri
     }),
     writeProvider: new BlockServiceADFWriteProvider({
       cloudId,
@@ -707,8 +858,7 @@ export const useMemoizedBlockServiceAPIProviders = ({
   parentAri,
   parentId,
   product,
-  getVersion,
-  relayEnvironment
+  getVersion
 }) => {
   return useMemo(() => {
     return createBlockServiceAPIProviders({
@@ -716,10 +866,9 @@ export const useMemoizedBlockServiceAPIProviders = ({
       parentAri,
       parentId,
       product,
-      getVersion,
-      relayEnvironment
+      getVersion
     });
-  }, [cloudId, parentAri, parentId, product, getVersion, relayEnvironment]);
+  }, [cloudId, parentAri, parentId, product, getVersion]);
 };
 const createBlockServiceFetchOnlyAPIProvider = ({
   cloudId,

package/dist/es2019/providers/syncBlockProvider.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { useMemo } from 'react';
+import { useMemo, useRef } from 'react';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { conditionalHooksFactory } from '@atlaskit/platform-feature-flags-react';
 import { getProductFromSourceAri } from '../clients/block-service/ari';
 import { getPageIdAndTypeFromConfluencePageAri } from '../clients/confluence/ari';
 import { fetchConfluencePageInfo } from '../clients/confluence/sourceInfo';
@@ -103,6 +104,32 @@ export class SyncedBlockProvider extends SyncBlockDataProviderInterface {
     if (!this.writeProvider) {
       return Promise.reject(new Error('Write provider not set'));
     }
+
+    // Use batch write only when feature flag is enabled and method is available
+    if (this.writeProvider.writeDataBatch && fg('platform_synced_block_patch_4')) {
+      // Separate data into valid (with content) and invalid (without content)
+      const validDataWithIndices = [];
+      const invalidResults = [];
+      data.forEach(blockData => {
+        if (blockData.content) {
+          validDataWithIndices.push(blockData);
+        } else {
+          invalidResults.push({
+            error: 'No Synced Block content to write',
+            resourceId: blockData.resourceId
+          });
+        }
+      });
+
+      // Process valid data in batch
+      let batchResults = [];
+      if (validDataWithIndices.length > 0) {
+        batchResults = await this.writeProvider.writeDataBatch(validDataWithIndices);
+      }
+      return [...batchResults, ...invalidResults];
+    }
+
+    // Fall back to individual writes
     const results = await Promise.allSettled(nodes.map((_node, index) => {
       var _this$writeProvider;
       if (!this.writeProvider) {
@@ -289,7 +316,7 @@ const createSyncedBlockProvider = ({
 }) => {
   return new SyncedBlockProvider(fetchProvider, writeProvider);
 };
-export const useMemoizedSyncedBlockProvider = ({
+const useMemoizedSyncedBlockProviderBase = ({
   fetchProvider,
   writeProvider,
   providerOptions,
@@ -305,4 +332,30 @@ export const useMemoizedSyncedBlockProvider = ({
     syncBlockProvider.setSSRData(ssrData);
   }
   return syncBlockProvider;
-};
+};
+const useMemoizedSyncedBlockProviderPatched = ({
+  fetchProvider,
+  writeProvider,
+  providerOptions,
+  getSSRData
+}) => {
+  const syncBlockProvider = useMemo(() => createSyncedBlockProvider({
+    fetchProvider,
+    writeProvider
+  }), [fetchProvider, writeProvider]);
+  const prevProviderOptionsRef = useRef(undefined);
+  if (providerOptions !== prevProviderOptionsRef.current) {
+    prevProviderOptionsRef.current = providerOptions;
+    syncBlockProvider.setProviderOptions(providerOptions);
+  }
+  const prevSSRDataRef = useRef(undefined);
+  const ssrData = getSSRData === null || getSSRData === void 0 ? void 0 : getSSRData();
+  if (ssrData !== prevSSRDataRef.current) {
+    prevSSRDataRef.current = ssrData;
+    if (ssrData) {
+      syncBlockProvider.setSSRData(ssrData);
+    }
+  }
+  return syncBlockProvider;
+};
+export const useMemoizedSyncedBlockProvider = conditionalHooksFactory(() => fg('platform_synced_block_patch_4'), useMemoizedSyncedBlockProviderPatched, useMemoizedSyncedBlockProviderBase);

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

@@ -277,6 +277,9 @@ export class ReferenceSyncBlockStoreManager {
    */
   handleGraphQLSubscriptionUpdate(syncBlockInstance) {
     if (!syncBlockInstance.resourceId) {
+      if (fg('platform_synced_block_patch_4')) {
+        return;
+      }
       throw new Error('Sync block instance provided to graphql subscription update missing resource id');
     }
     const existingSyncBlock = this.getFromCache(syncBlockInstance.resourceId);

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

@@ -1,5 +1,7 @@
-import { useMemo } from 'react';
+import { useMemo, useRef } from 'react';
 import { logException } from '@atlaskit/editor-common/monitoring';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { conditionalHooksFactory } from '@atlaskit/platform-feature-flags-react';
 import { getProductFromSourceAri } from '../clients/block-service/ari';
 import { SyncBlockError } from '../common/types';
 import { fetchReferencesErrorPayload } from '../utils/errorHandling';
@@ -14,7 +16,7 @@ import { SourceSyncBlockStoreManager } from './sourceSyncBlockStoreManager';
 // Can be used in both editor and renderer contexts.
 export class SyncBlockStoreManager {
   constructor(dataProvider) {
-    // In future, if reference manager needs to reach to source manager and read it's current in memorey cache
+    // In future, if reference manager needs to reach to source manager and read its current in memory cache
     // we can pass the source manager as a parameter to the reference manager constructor
     this.sourceSyncBlockStoreManager = new SourceSyncBlockStoreManager(dataProvider);
     this.referenceSyncBlockStoreManager = new ReferenceSyncBlockStoreManager(dataProvider);
@@ -128,11 +130,22 @@ export class SyncBlockStoreManager {
 const createSyncBlockStoreManager = dataProvider => {
   return new SyncBlockStoreManager(dataProvider);
 };
-export const useMemoizedSyncBlockStoreManager = (dataProvider, fireAnalyticsEvent) => {
+const useMemoizedSyncBlockStoreManagerBase = (dataProvider, fireAnalyticsEvent) => {
   const syncBlockStoreManager = useMemo(() => {
-    const syncBlockStoreManager = createSyncBlockStoreManager(dataProvider);
-    return syncBlockStoreManager;
+    return createSyncBlockStoreManager(dataProvider);
   }, [dataProvider]);
   syncBlockStoreManager.setFireAnalyticsEvent(fireAnalyticsEvent);
   return syncBlockStoreManager;
-};
+};
+const useMemoizedSyncBlockStoreManagerPatched = (dataProvider, fireAnalyticsEvent) => {
+  const syncBlockStoreManager = useMemo(() => {
+    return createSyncBlockStoreManager(dataProvider);
+  }, [dataProvider]);
+  const prevFireAnalyticsEventRef = useRef(undefined);
+  if (fireAnalyticsEvent !== prevFireAnalyticsEventRef.current) {
+    prevFireAnalyticsEventRef.current = fireAnalyticsEvent;
+    syncBlockStoreManager.setFireAnalyticsEvent(fireAnalyticsEvent);
+  }
+  return syncBlockStoreManager;
+};
+export const useMemoizedSyncBlockStoreManager = conditionalHooksFactory(() => fg('platform_synced_block_patch_4'), useMemoizedSyncBlockStoreManagerPatched, useMemoizedSyncBlockStoreManagerBase);

package/dist/es2019/utils/experienceTracking.js

@@ -81,9 +81,9 @@ export const getFetchSourceInfoExperience = fireAnalyticsEvent => {
 /**
  * This experience tracks when a source sync block is deleted from the BE.
  *
- * Start: When the fetchSourceInfo function is called.
- * Success: When the fetching the data is successful within the timeout duration of start.
- * Failure: When the timeout duration passes without the data being successfully fetched, or the fetch fails
+ * Start: When the delete source sync block function is called.
+ * Success: When the sync block deletion is successful within the timeout duration of start.
+ * Failure: When the timeout duration passes without the sync block being successfully deleted, or the deletion fails
  */
 export const getDeleteSourceExperience = fireAnalyticsEvent => {
   return new Experience(EXPERIENCE_ID.ASYNC_OPERATION, {
@@ -98,9 +98,9 @@ export const getDeleteSourceExperience = fireAnalyticsEvent => {
 /**
  * This experience tracks when a source sync block is created and registered to the BE.
  *
- * Start: When the fetchSourceInfo function is called.
- * Success: When the fetching the data is successful within the timeout duration of start.
- * Failure: When the timeout duration passes without the data being successfully fetched, or the fetch fails
+ * Start: When the create source sync block function is called.
+ * Success: When the sync block creation is successful within the timeout duration of start.
+ * Failure: When the timeout duration passes without the sync block being successfully created, or the creation fails
  */
 export const getCreateSourceExperience = fireAnalyticsEvent => {
   return new Experience(EXPERIENCE_ID.ASYNC_OPERATION, {
@@ -113,11 +113,11 @@ export const getCreateSourceExperience = fireAnalyticsEvent => {
 };
 
 /**
- * This experience tracks when a source sync block is created and registered to the BE.
+ * This experience tracks when references for a sync block are fetched from the BE.
  *
- * Start: When the fetchSourceInfo function is called.
- * Success: When the fetching the data is successful within the timeout duration of start.
- * Failure: When the timeout duration passes without the data being successfully fetched, or the fetch fails
+ * Start: When the fetchReferences function is called.
+ * Success: When the fetching of references is successful within the timeout duration of start.
+ * Failure: When the timeout duration passes without references being successfully fetched, or the fetch fails
  */
 export const getFetchReferencesExperience = fireAnalyticsEvent => {
   return new Experience(EXPERIENCE_ID.ASYNC_OPERATION, {

package/dist/es2019/utils/resourceId.js

@@ -11,7 +11,7 @@ const isSyncBlockProduct = product => {
  *
  * Format
  * - {product}/{contentId}/{uuid}
- *   - product: a recognized `SyncBlockProduct` (e.g. 'confluence-page', 'jira-issue')
+ *   - product: a recognized `SyncBlockProduct` (e.g. 'confluence-page', 'jira-work-item')
  *   - contentId: the host content identifier (e.g. page ID or issue ID)
  *   - uuid: the UUID for the specific synced block instance
  *
@@ -24,7 +24,7 @@ const isSyncBlockProduct = product => {
  * - No extra segments; returns `undefined` on any invalid input
  *
  * Notes
- * - `product` is a qualified domain like 'confluence-page' or 'jira-issue',
+ * - `product` is a qualified domain like 'confluence-page' or 'jira-work-item',
  *   not just 'confluence' or 'jira'.
  */
 

package/dist/es2019/utils/retry.js

@@ -1,7 +1,10 @@
-const parseRetryAfter = retryAfter => {
+import { fg } from '@atlaskit/platform-feature-flags';
+import { functionWithCondition } from '@atlaskit/platform-feature-flags-react';
+const MAX_RETRY_DELAY = 30000;
+const parseRetryAfterBase = retryAfter => {
   let newDelay;
 
-  // retryAfter can either be in ms or HTTP date
+  // retryAfter can either be in seconds or HTTP date
   const parsedRetryAfter = parseInt(retryAfter);
   if (!isNaN(parsedRetryAfter)) {
     newDelay = parsedRetryAfter * 1000;
@@ -14,16 +17,33 @@ const parseRetryAfter = retryAfter => {
   }
   return newDelay;
 };
+const parseRetryAfterPatched = retryAfter => {
+  // retryAfter can either be in seconds or HTTP date
+  const parsedRetryAfter = parseInt(retryAfter, 10);
+  if (!isNaN(parsedRetryAfter) && parsedRetryAfter > 0) {
+    return parsedRetryAfter * 1000;
+  }
+  const retryDate = new Date(retryAfter);
+  if (isNaN(retryDate.getTime())) {
+    return undefined;
+  }
+  const delayFromDate = retryDate.getTime() - Date.now();
+  if (delayFromDate > 0) {
+    return delayFromDate;
+  }
+  return undefined;
+};
+const parseRetryAfter = functionWithCondition(() => fg('platform_synced_block_patch_4'), parseRetryAfterPatched, parseRetryAfterBase);
 export const fetchWithRetry = async (url, options, retriesRemaining = 3, delay = 1000) => {
+  var _ref;
   const response = await fetch(url, options);
   const shouldRetry = !response.ok && response.status === 429 && retriesRemaining > 1;
   if (!shouldRetry) {
     return response;
   }
   const retryAfter = response.headers.get('Retry-After');
-  await new Promise(resolve => {
-    var _ref;
-    return setTimeout(resolve, (_ref = retryAfter ? parseRetryAfter(retryAfter) : undefined) !== null && _ref !== void 0 ? _ref : delay);
-  });
+  const parsedDelay = (_ref = retryAfter ? parseRetryAfter(retryAfter) : undefined) !== null && _ref !== void 0 ? _ref : delay;
+  const retryDelay = fg('platform_synced_block_patch_4') ? Math.min(parsedDelay, MAX_RETRY_DELAY) : parsedDelay;
+  await new Promise(resolve => setTimeout(resolve, retryDelay));
   return fetchWithRetry(url, options, retriesRemaining - 1, delay * 2);
 };

package/dist/es2019/utils/utils.js

@@ -30,7 +30,7 @@ export const convertPMNodeToSyncBlockNode = node => {
   return createSyncBlockNode(node.attrs.localId, node.attrs.resourceId);
 };
 export const convertPMNodesToSyncBlockNodes = nodes => {
-  return nodes.map(node => convertPMNodeToSyncBlockNode(node)).filter(node => node !== undefined) || [];
+  return nodes.map(node => convertPMNodeToSyncBlockNode(node)).filter(node => node !== undefined);
 };
 
 /*

package/dist/es2019/utils/validValue.js

@@ -1,5 +1,6 @@
+import { SYNC_BLOCK_PRODUCTS } from '../common/consts';
 export const normaliseSyncBlockProduct = value => {
-  return value === 'confluence-page' || value === 'jira-work-item' ? value : undefined;
+  return SYNC_BLOCK_PRODUCTS.includes(value) ? value : undefined;
 };
 export const normaliseSyncBlockStatus = value => {
   return value === 'active' || value === 'unpublished' || value === 'deleted' ? value : undefined;