@atlaskit/editor-synced-block-provider 2.2.3 → 2.3.1

package/dist/cjs/utils/mergeFetchSyncBlockDataResult.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveFetchSyncBlockDataResult = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Merges two FetchSyncBlockDataResult objects,
+ * currently it only preserves the sourceURL from the old result,
+ * but this can be extended in the future to preserve other fields and resolve conflicts as needed.
+ * e.g. compare timestamps or version numbers to determine which data is more recent.
+ *
+ * @param oldResult - The existing FetchSyncBlockDataResult object.
+ * @param newResult - The new FetchSyncBlockDataResult object to merge.
+ * @returns A merged FetchSyncBlockDataResult object.
+ */
+var resolveFetchSyncBlockDataResult = exports.resolveFetchSyncBlockDataResult = function resolveFetchSyncBlockDataResult(oldResult, newResult) {
+  var _newResult$data, _oldResult$data;
+  // if the old result has no data, we simple return the new result
+  if (!oldResult.data) {
+    return newResult;
+  } else if (!newResult.data) {
+    // if the new result has no data, we simply return the old result
+    // TODO: EDITOR-2533 - handle this case based on the error type and whether we should keep old data or not
+    return oldResult;
+  }
+
+  // otherwise, we merge the two results, preserving the sourceURL from the old result if it exists
+  return _objectSpread(_objectSpread({}, newResult), {}, {
+    data: _objectSpread(_objectSpread({}, newResult.data), {}, {
+      sourceURL: ((_newResult$data = newResult.data) === null || _newResult$data === void 0 ? void 0 : _newResult$data.sourceURL) || ((_oldResult$data = oldResult.data) === null || _oldResult$data === void 0 ? void 0 : _oldResult$data.sourceURL) || undefined
+    })
+  });
+};

package/dist/es2019/hooks/useFetchSyncBlockData.js

@@ -1,39 +1,14 @@
-import { useCallback, useEffect, useState } from 'react';
-import { SyncBlockError } from '../common/types';
+import { useEffect, useState } from 'react';
 export const SYNC_BLOCK_FETCH_INTERVAL = 3000;
 export const useFetchSyncBlockData = (manager, syncBlockNode) => {
   const [fetchSyncBlockDataResult, setFetchSyncBlockDataResult] = useState(null);
-  const fetchSyncBlockNode = useCallback(() => {
-    manager.fetchSyncBlockData(syncBlockNode).then(data => {
-      if (data !== null && data !== void 0 && data.error) {
-        // if there is an error, we don't want to replace real existing data with the error data
-        setFetchSyncBlockDataResult(prev => {
-          if (!prev || prev.error) {
-            return data;
-          }
-          return prev;
-        });
-      } else {
-        setFetchSyncBlockDataResult(data !== null && data !== void 0 ? data : null);
-      }
-    }).catch(() => {
-      //TODO: EDITOR-1921 - add error analytics
-      setFetchSyncBlockDataResult(prev => {
-        if (!prev || prev.error) {
-          return {
-            error: SyncBlockError.Errored
-          };
-        }
-        return prev;
-      });
-    });
-  }, [manager, syncBlockNode]);
   useEffect(() => {
-    fetchSyncBlockNode();
-    const interval = window.setInterval(fetchSyncBlockNode, SYNC_BLOCK_FETCH_INTERVAL);
+    const unsubscribe = manager.subscribeToSyncBlockData(syncBlockNode, data => {
+      setFetchSyncBlockDataResult(data);
+    });
     return () => {
-      window.clearInterval(interval);
+      unsubscribe();
     };
-  }, [fetchSyncBlockNode]);
+  }, [manager, setFetchSyncBlockDataResult, syncBlockNode]);
   return fetchSyncBlockDataResult;
 };

package/dist/es2019/providers/confluence/confluenceContentAPI.js

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { useMemo } from 'react';
 import { SyncBlockError } from '../../common/types';
 import { getLocalIdFromAri, getPageIdAndTypeFromAri } from '../../utils/ari';
-import { getContentProperty, createContentProperty, updateContentProperty } from '../../utils/contentProperty';
+import { getContentProperty, createContentProperty, updateContentProperty, deleteContentProperty } from '../../utils/contentProperty';
 import { isBlogPageType } from '../../utils/utils';
 
 /**
@@ -175,6 +175,36 @@ class ConfluenceADFWriteProvider {
       return this.createNewContentProperty(pageId, key, data, pageType);
     }
   }
+  async deleteData(resourceId) {
+    const {
+      id: pageId,
+      type: pageType
+    } = getPageIdAndTypeFromAri(resourceId);
+    const localId = getLocalIdFromAri(resourceId);
+    const key = getContentPropertyKey(this.config.contentPropertyKey, localId);
+    const options = {
+      pageId,
+      key,
+      cloudId: this.config.cloudId,
+      pageType
+    };
+    let deletePayload, deleteResult;
+    try {
+      deletePayload = await deleteContentProperty(options);
+      deleteResult = isBlogPageType(pageType) ? deletePayload.data.confluence.deleteBlogPostProperty : deletePayload.data.confluence.deletePageProperty;
+    } catch {
+      return {
+        resourceId,
+        success: false,
+        error: `Fail to delete ${pageType} content property`
+      };
+    }
+    return {
+      resourceId,
+      success: deleteResult.success,
+      error: deleteResult.errors.join()
+    };
+  }
 }
 
 /**

package/dist/es2019/providers/in-memory/inMemory.js

@@ -21,5 +21,12 @@ export const inMemoryWriteProvider = {
       inMemStore.set(uuid, data);
       return Promise.resolve(uuid);
     }
+  },
+  deleteData: resourceId => {
+    const success = inMemStore.delete(resourceId);
+    return Promise.resolve({
+      resourceId,
+      success
+    });
   }
 };

package/dist/es2019/providers/syncBlockProvider.js

@@ -1,5 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { useMemo } from 'react';
+import { SyncBlockError } from '../common/types';
 import { SyncBlockDataProvider } from '../providers/types';
 import { getLocalIdFromAri, getPageARIFromResourceId } from '../utils/ari';
 export class SyncBlockProvider extends SyncBlockDataProvider {
@@ -17,9 +18,22 @@ export class SyncBlockProvider extends SyncBlockDataProvider {
     return node.attrs.localId;
   }
   fetchNodesData(nodes) {
-    return Promise.all(nodes.map(node => {
-      return this.fetchProvider.fetchData(node.attrs.resourceId);
-    }));
+    const resourceIdSet = new Set(nodes.map(node => node.attrs.resourceId));
+    const resourceIds = [...resourceIdSet];
+    return Promise.allSettled(resourceIds.map(resourceId => {
+      return this.fetchProvider.fetchData(resourceId).then(data => {
+        return data;
+      }, () => {
+        return {
+          status: SyncBlockError.Errored,
+          resourceId
+        };
+      });
+    })).then(results => {
+      return results.filter(result => {
+        return result.status === 'fulfilled';
+      }).map(result => result.value);
+    });
   }
 
   /**
@@ -41,6 +55,20 @@ export class SyncBlockProvider extends SyncBlockDataProvider {
     });
     return Promise.all(resourceIds);
   }
+  async deleteNodesData(resourceIds) {
+    const results = await Promise.allSettled(resourceIds.map(resourceId => this.writeProvider.deleteData(resourceId)));
+    return results.map((result, index) => {
+      if (result.status === 'fulfilled') {
+        return result.value;
+      } else {
+        return {
+          resourceId: resourceIds[index],
+          success: false,
+          error: result.reason
+        };
+      }
+    });
+  }
   getSourceId() {
     return this.sourceId;
   }

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

@@ -1,3 +1,5 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { resolveFetchSyncBlockDataResult } from '../utils/mergeFetchSyncBlockDataResult';
 const createSyncBlockNode = (localId, resourceId) => {
   return {
     type: 'syncBlock',
@@ -9,80 +11,206 @@ const createSyncBlockNode = (localId, resourceId) => {
 };
 export class ReferenceSyncBlockStoreManager {
   constructor(dataProvider) {
-    this.dataProvider = dataProvider;
+    _defineProperty(this, "isInitialized", false);
+    _defineProperty(this, "isRefreshingSubscriptions", false);
     this.syncBlockCache = new Map();
+    this.subscriptions = new Map();
+    this.dataProvider = dataProvider;
     this.syncBlockURLRequests = new Map();
   }
+  async init(editorView) {
+    if (!this.editorView && !this.isInitialized) {
+      this.editorView = editorView;
+      const syncBlockNodes = editorView.state.doc.children.filter(node => node.type.name === 'syncBlock').map(node => {
+        return node.toJSON();
+      }) || [];
+      if (syncBlockNodes.length > 0) {
+        try {
+          const dataResults = await this.fetchSyncBlocksData(syncBlockNodes);
+          if (!dataResults) {
+            throw new Error('No data results returned when initializing sync block store manager');
+          }
+          dataResults.forEach(dataResult => {
+            this.updateCache(dataResult);
+          });
+        } catch (error) {
+          // TODO: EDITOR-1921 - add error analytics
+        }
+      }
+    }
+    this.isInitialized = true;
+  }
 
   /**
-   *
-   * @param localId - The local ID of the sync block to get the source URL for
-   * @param resourceId - The resource ID of the sync block to get the source URL for
-   * Fetches source URl for a sync block and updates sync block data with the source URL asynchronously.
+   * Refreshes the subscriptions for all sync blocks.
+   * @returns {Promise<void>}
    */
-  fetchSyncBlockSourceURL({
-    localId,
-    resourceId
-  }) {
-    if (!localId || !resourceId || !this.dataProvider) {
+  async refreshSubscriptions() {
+    if (this.isRefreshingSubscriptions || !this.isInitialized) {
+      return;
+    }
+    this.isRefreshingSubscriptions = true;
+    const syncBlocks = [];
+    for (const [resourceId, callbacks] of this.subscriptions.entries()) {
+      Object.keys(callbacks).forEach(localId => {
+        syncBlocks.push(createSyncBlockNode(localId, resourceId));
+      });
+    }
+    try {
+      // fetch latest data for all subscribed sync blocks
+      // this function will update the cache and call the subscriptions
+      await this.fetchSyncBlocksData(syncBlocks);
+    } catch (error) {
+      // TODO: EDITOR-1921 - add error analytics
+    } finally {
+      this.isRefreshingSubscriptions = false;
+    }
+  }
+  fetchSyncBlockSourceURL(resourceId) {
+    if (!resourceId || !this.dataProvider) {
       return;
     }
 
     // if the sync block is a reference block, we need to fetch the URL to the source
     // we could optimise this further by checking if the sync block is on the same page as the source
-    if (!this.syncBlockURLRequests.get(localId)) {
-      this.syncBlockURLRequests.set(localId, true);
-      this.dataProvider.retrieveSyncBlockSourceUrl(createSyncBlockNode(localId, resourceId)).then(sourceURL => {
-        const existingSyncBlock = this.syncBlockCache.get(localId);
-        if (existingSyncBlock) {
-          existingSyncBlock.sourceURL = sourceURL;
+    if (!this.syncBlockURLRequests.get(resourceId)) {
+      this.syncBlockURLRequests.set(resourceId, true);
+      this.dataProvider.retrieveSyncBlockSourceUrl(createSyncBlockNode('', resourceId)).then(sourceURL => {
+        const existingSyncBlock = this.getFromCache(resourceId);
+        if (existingSyncBlock && existingSyncBlock.data) {
+          existingSyncBlock.data = {
+            ...existingSyncBlock.data,
+            sourceURL
+          };
+          this.updateCache(existingSyncBlock);
         }
       }).finally(() => {
-        this.syncBlockURLRequests.set(localId, false);
+        this.syncBlockURLRequests.set(resourceId, false);
       });
     }
   }
+
+  /**
+   * Fetch sync block data for a given sync block node.
+   * @param syncBlockNode - The sync block node to fetch data for
+   * @returns The fetched sync block data result
+   */
   async fetchSyncBlockData(syncBlockNode) {
     if (!this.dataProvider) {
       throw new Error('Data provider not set');
     }
     const syncNode = createSyncBlockNode(syncBlockNode.attrs.localId, syncBlockNode.attrs.resourceId);
-
-    // async fetch source URL if it is not already fetched
-    const existingSyncBlock = this.syncBlockCache.get(syncBlockNode.attrs.localId);
-    if (!(existingSyncBlock !== null && existingSyncBlock !== void 0 && existingSyncBlock.sourceURL)) {
-      this.fetchSyncBlockSourceURL({
-        localId: syncBlockNode.attrs.localId,
-        resourceId: syncBlockNode.attrs.resourceId
-      });
+    const data = await this.fetchSyncBlocksData([syncNode]);
+    if (!data || data.length === 0) {
+      throw new Error('Failed to fetch sync block data');
     }
-    let data;
-    try {
-      data = await this.dataProvider.fetchNodesData([syncNode]);
-      if (!data) {
-        throw new Error('Failed to fetch sync block node data');
-      }
-    } catch (error) {
+    return data[0];
+  }
+  async fetchSyncBlocksData(syncBlockNodes) {
+    if (!this.dataProvider) {
+      throw new Error('Data provider not set');
+    }
+    const data = await this.dataProvider.fetchNodesData(syncBlockNodes);
+    if (!data) {
       throw new Error('Failed to fetch sync block node data');
     }
-    const fetchSyncBlockDataResult = data[0];
-    if (!fetchSyncBlockDataResult.error && fetchSyncBlockDataResult.data) {
-      // only adds it to the map if it did not error out
-      this.syncBlockCache.set(syncBlockNode.attrs.localId, {
-        ...existingSyncBlock,
-        ...fetchSyncBlockDataResult.data
-      });
+    const resolvedData = [];
+    data.forEach(fetchSyncBlockDataResult => {
+      var _resolvedFetchSyncBlo;
+      if (!fetchSyncBlockDataResult.resourceId) {
+        return;
+      }
+      const existingSyncBlock = this.getFromCache(fetchSyncBlockDataResult.resourceId);
+      const resolvedFetchSyncBlockDataResult = existingSyncBlock ? resolveFetchSyncBlockDataResult(existingSyncBlock, fetchSyncBlockDataResult) : fetchSyncBlockDataResult;
+      this.updateCache(resolvedFetchSyncBlockDataResult);
+      resolvedData.push(resolvedFetchSyncBlockDataResult);
+
+      // fetch source URL if not already present
+      if (!((_resolvedFetchSyncBlo = resolvedFetchSyncBlockDataResult.data) !== null && _resolvedFetchSyncBlo !== void 0 && _resolvedFetchSyncBlo.sourceURL) && resolvedFetchSyncBlockDataResult.resourceId) {
+        this.fetchSyncBlockSourceURL(resolvedFetchSyncBlockDataResult.resourceId);
+      }
+    });
+    return resolvedData;
+  }
+  updateCache(syncBlock) {
+    const {
+      resourceId
+    } = syncBlock;
+    if (resourceId) {
+      this.syncBlockCache.set(resourceId, syncBlock);
+      const callbacks = this.subscriptions.get(resourceId);
+      if (callbacks) {
+        Object.values(callbacks).forEach(callback => {
+          callback(syncBlock);
+        });
+      }
+    }
+  }
+  getFromCache(resourceId) {
+    return this.syncBlockCache.get(resourceId);
+  }
+  deleteFromCache(resourceId) {
+    this.syncBlockCache.delete(resourceId);
+  }
+  subscribe(node, callback) {
+    // check node is a sync block, as we only support sync block subscriptions
+    if (node.type.name !== 'syncBlock') {
+      return () => {};
     }
-    return fetchSyncBlockDataResult;
+    const {
+      resourceId,
+      localId
+    } = node.attrs;
+    if (!localId || !resourceId) {
+      return () => {};
+    }
+
+    // add to subscriptions map
+    const resourceSubscriptions = this.subscriptions.get(resourceId) || {};
+    this.subscriptions.set(resourceId, {
+      ...resourceSubscriptions,
+      [localId]: callback
+    });
+
+    // call the callback immediately if we have cached data
+    const cachedData = this.getFromCache(resourceId);
+    if (cachedData) {
+      callback(cachedData);
+    } else {
+      this.fetchSyncBlockData(node).catch(() => {});
+    }
+    return () => {
+      const resourceSubscriptions = this.subscriptions.get(resourceId);
+      if (resourceSubscriptions) {
+        delete resourceSubscriptions[localId];
+        if (Object.keys(resourceSubscriptions).length === 0) {
+          this.subscriptions.delete(resourceId);
+          this.deleteFromCache(resourceId);
+        } else {
+          this.subscriptions.set(resourceId, resourceSubscriptions);
+        }
+      }
+    };
   }
 
   /**
    * Get the URL for a sync block.
-   * @param localId - The local ID of the sync block to get the URL for
+   * @param resourceId - The resource ID of the sync block
    * @returns
    */
-  getSyncBlockURL(localId) {
-    const syncBlock = this.syncBlockCache.get(localId);
-    return syncBlock === null || syncBlock === void 0 ? void 0 : syncBlock.sourceURL;
+  getSyncBlockURL(resourceId) {
+    var _syncBlock$data;
+    const syncBlock = this.getFromCache(resourceId);
+    if (!syncBlock) {
+      return undefined;
+    }
+    return (_syncBlock$data = syncBlock.data) === null || _syncBlock$data === void 0 ? void 0 : _syncBlock$data.sourceURL;
+  }
+  destroy() {
+    this.syncBlockCache.clear();
+    this.subscriptions.clear();
+    this.syncBlockURLRequests.clear();
+    this.editorView = undefined;
+    this.isInitialized = false;
   }
 }

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

@@ -95,10 +95,22 @@ export class SourceSyncBlockStoreManager {
       if (confirmed) {
         var _this$editorView;
         (_this$editorView = this.editorView) === null || _this$editorView === void 0 ? void 0 : _this$editorView.dispatch(this.confirmationTransaction.setMeta('isConfirmedSyncBlockDeletion', true));
-        // Need to update the BE on deletion
-        syncBlockIds.forEach(({
-          localId
-        }) => this.syncBlockCache.delete(localId));
+        try {
+          if (!this.dataProvider) {
+            throw new Error('Data provider not set');
+          }
+          const results = await this.dataProvider.deleteNodesData(syncBlockIds.map(attrs => attrs.resourceId));
+          results.forEach(result => {
+            if (result.success) {
+              // Only delete when it's deleted successfully in backend
+              this.syncBlockCache.delete(result.resourceId);
+            } else {
+              // TODO: EDITOR-1921 - add error analytics with result.error
+            }
+          });
+        } catch (_error) {
+          // TODO: EDITOR-1921 - add error analytics
+        }
       }
       this.confirmationTransaction = undefined;
     }

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

@@ -11,6 +11,12 @@ export class SyncBlockStoreManager {
     this.referenceSyncBlockStoreManager = new ReferenceSyncBlockStoreManager(dataProvider);
     this.sourceSyncBlockStoreManager = new SourceSyncBlockStoreManager(dataProvider);
   }
+
+  /**
+   * Fetch sync block data for a given sync block node.
+   * @param syncBlockNode - The sync block node to fetch data for
+   * @returns The fetched sync block data result
+   */
   fetchSyncBlockData(syncBlockNode) {
     if (!['bodiedSyncBlock', 'syncBlock'].includes(syncBlockNode.type.name)) {
       throw new Error('Node is not a sync block');
@@ -45,16 +51,18 @@ export class SyncBlockStoreManager {
 
   /**
    * Get the URL for a sync block.
-   * @param localId - The local ID of the sync block to get the URL for
+   * @param resourceId - The resource ID of the sync block to get the URL for
    * @returns
    */
-  getSyncBlockURL(localId) {
+  getSyncBlockURL(resourceId) {
     // only applicable to reference sync block, for now (will be refactored further)
-    return this.referenceSyncBlockStoreManager.getSyncBlockURL(localId);
+    return this.referenceSyncBlockStoreManager.getSyncBlockURL(resourceId);
   }
   setEditorView(editorView) {
-    // only applicable to source sync block, for now (will be refactored further)
     this.sourceSyncBlockStoreManager.setEditorView(editorView);
+    if (editorView) {
+      this.referenceSyncBlockStoreManager.init(editorView);
+    }
   }
   isSourceBlock(node) {
     return node.type.name === 'bodiedSyncBlock';
@@ -71,6 +79,12 @@ export class SyncBlockStoreManager {
     // only applicable to source sync block, for now (will be refactored further)
     return this.sourceSyncBlockStoreManager.createSyncBlockNode();
   }
+  subscribeToSyncBlockData(node, callback) {
+    return this.referenceSyncBlockStoreManager.subscribe(node, callback);
+  }
+  refreshSubscriptions() {
+    this.referenceSyncBlockStoreManager.refreshSubscriptions();
+  }
   deleteSyncBlocksWithConfirmation(tr, syncBlockIds) {
     // only applicable to source sync block, for now (will be refactored further)
     return this.sourceSyncBlockStoreManager.deleteSyncBlocksWithConfirmation(tr, syncBlockIds);
@@ -79,4 +93,7 @@ export class SyncBlockStoreManager {
     // only applicable to source sync block, for now (will be refactored further)
     this.sourceSyncBlockStoreManager.rebaseTransaction(incomingTr, state);
   }
+  destroy() {
+    this.referenceSyncBlockStoreManager.destroy();
+  }
 }

package/dist/es2019/utils/contentProperty.js

@@ -11,6 +11,7 @@ const GRAPHQL_ENDPOINT = '/gateway/api/graphql';
 const GET_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_GET';
 const CREATE_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_CREATE';
 const UPDATE_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_UPDATE';
+const DELETE_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_DELETE';
 /**
  * Query to get the page property by key
  * @param documentARI
@@ -116,6 +117,24 @@ const UPDATE_BLOG_QUERY = `mutation ${UPDATE_OPERATION_NAME} ($input: Confluence
 		}
 	}
 }`;
+const DELETE_PAGE_QUERY = `mutation ${DELETE_OPERATION_NAME} ($input: ConfluenceDeletePagePropertyInput!) {
+						confluence {
+							deletePageProperty(input: $input) {
+								success, errors {
+								  message
+								}
+							}
+						}
+					}`;
+const DELETE_BLOG_QUERY = `mutation ${DELETE_OPERATION_NAME} ($input: ConfluenceDeleteBlogPostPropertyInput!) {
+						confluence {
+							deleteBlogPostProperty(input: $input) {
+								success, errors {
+								  message
+								}
+							}
+						}
+					}`;
 export const getContentProperty = async ({
   pageId,
   key,
@@ -234,4 +253,39 @@ export const createContentProperty = async ({
     throw new Error(`Failed to create content property: ${response.statusText}`);
   }
   return await response.json();
+};
+export const deleteContentProperty = async ({
+  pageId,
+  cloudId,
+  pageType,
+  key
+}) => {
+  const documentARI = getConfluencePageAri(pageId, cloudId, pageType);
+  const isBlog = isBlogPageType(pageType);
+  const bodyData = {
+    query: isBlog ? DELETE_BLOG_QUERY : DELETE_PAGE_QUERY,
+    operationName: DELETE_OPERATION_NAME,
+    variables: {
+      input: {
+        ...(isBlog ? {
+          blogPostId: documentARI
+        } : {
+          pageId: documentARI
+        }),
+        key
+      }
+    }
+  };
+  const response = await fetch(GRAPHQL_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      ...COMMON_HEADERS,
+      ...AGG_HEADERS
+    },
+    body: JSON.stringify(bodyData)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to delete content property: ${response.statusText}`);
+  }
+  return await response.json();
 };

package/dist/es2019/utils/mergeFetchSyncBlockDataResult.js

@@ -0,0 +1,30 @@
+/**
+ * Merges two FetchSyncBlockDataResult objects,
+ * currently it only preserves the sourceURL from the old result,
+ * but this can be extended in the future to preserve other fields and resolve conflicts as needed.
+ * e.g. compare timestamps or version numbers to determine which data is more recent.
+ *
+ * @param oldResult - The existing FetchSyncBlockDataResult object.
+ * @param newResult - The new FetchSyncBlockDataResult object to merge.
+ * @returns A merged FetchSyncBlockDataResult object.
+ */
+export const resolveFetchSyncBlockDataResult = (oldResult, newResult) => {
+  var _newResult$data, _oldResult$data;
+  // if the old result has no data, we simple return the new result
+  if (!oldResult.data) {
+    return newResult;
+  } else if (!newResult.data) {
+    // if the new result has no data, we simply return the old result
+    // TODO: EDITOR-2533 - handle this case based on the error type and whether we should keep old data or not
+    return oldResult;
+  }
+
+  // otherwise, we merge the two results, preserving the sourceURL from the old result if it exists
+  return {
+    ...newResult,
+    data: {
+      ...newResult.data,
+      sourceURL: ((_newResult$data = newResult.data) === null || _newResult$data === void 0 ? void 0 : _newResult$data.sourceURL) || ((_oldResult$data = oldResult.data) === null || _oldResult$data === void 0 ? void 0 : _oldResult$data.sourceURL) || undefined
+    }
+  };
+};