@atlaskit/editor-synced-block-provider 2.2.0 → 2.2.2

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

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SyncBlockStoreManager = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _referenceSyncBlockStoreManager = require("./referenceSyncBlockStoreManager");
+var _sourceSyncBlockStoreManager = require("./sourceSyncBlockStoreManager");
+// A store manager responsible for the lifecycle and state management of sync blocks in an editor instance.
+// Supports create, read, update, and delete operations for sync blocks.
+// Designed to manage local in-memory state and synchronize with an external data provider.
+// Handles caching, debouncing updates, and publish/subscribe for local changes.
+// Ensures consistency between local and remote state, and can be used in both editor and renderer contexts.
+var SyncBlockStoreManager = exports.SyncBlockStoreManager = /*#__PURE__*/function () {
+  function SyncBlockStoreManager(dataProvider) {
+    (0, _classCallCheck2.default)(this, SyncBlockStoreManager);
+    this.referenceSyncBlockStoreManager = new _referenceSyncBlockStoreManager.ReferenceSyncBlockStoreManager(dataProvider);
+    this.sourceSyncBlockStoreManager = new _sourceSyncBlockStoreManager.SourceSyncBlockStoreManager(dataProvider);
+  }
+  return (0, _createClass2.default)(SyncBlockStoreManager, [{
+    key: "fetchSyncBlockData",
+    value: function fetchSyncBlockData(syncBlockNode) {
+      if (this.isSourceBlock(syncBlockNode)) {
+        return Promise.reject(new Error('Invalid sync block node type provided for fetchSyncBlockData'));
+      }
+      return this.referenceSyncBlockStoreManager.fetchSyncBlockData(syncBlockNode);
+    }
+
+    /**
+     * Add/update a sync block node to/from the local cache
+     * @param syncBlockNode - The sync block node to update
+     */
+  }, {
+    key: "updateSyncBlockData",
+    value: function updateSyncBlockData(syncBlockNode) {
+      if (this.isSourceBlock(syncBlockNode)) {
+        this.sourceSyncBlockStoreManager.updateSyncBlockData(syncBlockNode);
+      } else {
+        throw new Error('Invalid sync block node type provided for updateSyncBlockData');
+      }
+    }
+
+    /**
+     * Save content of bodiedSyncBlock nodes in local cache to backend
+     *
+     * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+     */
+  }, {
+    key: "flushBodiedSyncBlocks",
+    value: function flushBodiedSyncBlocks() {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.flushBodiedSyncBlocks();
+    }
+
+    /**
+     * Get the URL for a sync block.
+     * @param localId - The local ID of the sync block to get the URL for
+     * @returns
+     */
+  }, {
+    key: "getSyncBlockURL",
+    value: function getSyncBlockURL(localId) {
+      // only applicable to reference sync block, for now (will be refactored further)
+      return this.referenceSyncBlockStoreManager.getSyncBlockURL(localId);
+    }
+  }, {
+    key: "setEditorView",
+    value: function setEditorView(editorView) {
+      // only applicable to source sync block, for now (will be refactored further)
+      this.sourceSyncBlockStoreManager.setEditorView(editorView);
+    }
+  }, {
+    key: "isSourceBlock",
+    value: function isSourceBlock(node) {
+      return node.type.name === 'bodiedSyncBlock';
+    }
+  }, {
+    key: "registerConfirmationCallback",
+    value: function registerConfirmationCallback(callback) {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.registerConfirmationCallback(callback);
+    }
+  }, {
+    key: "requireConfirmationBeforeDelete",
+    value: function requireConfirmationBeforeDelete() {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.requireConfirmationBeforeDelete();
+    }
+  }, {
+    key: "createSyncBlockNode",
+    value: function createSyncBlockNode() {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.createSyncBlockNode();
+    }
+  }, {
+    key: "deleteSyncBlocksWithConfirmation",
+    value: function deleteSyncBlocksWithConfirmation(tr, syncBlockIds) {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.deleteSyncBlocksWithConfirmation(tr, syncBlockIds);
+    }
+  }, {
+    key: "rebaseTransaction",
+    value: function rebaseTransaction(incomingTr, state) {
+      // only applicable to source sync block, for now (will be refactored further)
+      this.sourceSyncBlockStoreManager.rebaseTransaction(incomingTr, state);
+    }
+  }]);
+}();

package/dist/cjs/utils/utils.js

@@ -3,23 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isBlogPageType = exports.convertSyncBlockPMNodeToSyncBlockNode = exports.convertSyncBlockPMNodeToSyncBlockData = void 0;
-var _editorJsonTransformer = require("@atlaskit/editor-json-transformer");
-var convertSyncBlockPMNodeToSyncBlockNode = exports.convertSyncBlockPMNodeToSyncBlockNode = function convertSyncBlockPMNodeToSyncBlockNode(node) {
-  var includeContent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var transformer = new _editorJsonTransformer.JSONTransformer();
-  var toJSON = function toJSON(node) {
-    return transformer.encodeNode(node);
-  };
-  return {
-    type: node.type.name === 'bodiedSyncBlock' ? 'bodiedSyncBlock' : 'syncBlock',
-    attrs: {
-      localId: node.attrs.localId,
-      resourceId: node.attrs.resourceId
-    },
-    content: includeContent ? node.content.content.map(toJSON) : undefined
-  };
-};
+exports.isBlogPageType = exports.convertSyncBlockPMNodeToSyncBlockData = void 0;
 var convertSyncBlockPMNodeToSyncBlockData = exports.convertSyncBlockPMNodeToSyncBlockData = function convertSyncBlockPMNodeToSyncBlockData(node) {
   return {
     blockInstanceId: node.attrs.localId,

package/dist/es2019/common/types.js

@@ -1,8 +1,6 @@
-import { NodeDataProvider } from '@atlaskit/node-data-provider';
-export let SyncBlockStatus = /*#__PURE__*/function (SyncBlockStatus) {
-  SyncBlockStatus["Errored"] = "errored";
-  SyncBlockStatus["NotFound"] = "not_found";
-  SyncBlockStatus["Unauthorized"] = "unauthorized";
-  return SyncBlockStatus;
-}({});
-export class SyncBlockDataProvider extends NodeDataProvider {}
+export let SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
+  SyncBlockError["Errored"] = "errored";
+  SyncBlockError["NotFound"] = "not_found";
+  SyncBlockError["Forbidden"] = "forbidden";
+  return SyncBlockError;
+}({});

package/dist/es2019/hooks/useFetchSyncBlockData.js

@@ -0,0 +1,38 @@
+import { useCallback, useEffect, useState } from 'react';
+import { SyncBlockError } from '../common/types';
+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, 3000);
+    return () => {
+      window.clearInterval(interval);
+    };
+  }, [fetchSyncBlockNode]);
+  return fetchSyncBlockDataResult;
+};

package/dist/es2019/hooks/useHandleContentChanges.js

@@ -0,0 +1,7 @@
+import { useEffect } from 'react';
+export const useHandleContentChanges = (manager, syncBlockNode) => {
+  useEffect(() => {
+    //TODO: EDITOR-1921 - add error analytics
+    manager.updateSyncBlockData(syncBlockNode);
+  }, [manager, syncBlockNode]);
+};

package/dist/es2019/index.js

@@ -1,11 +1,13 @@
 /* eslint-disable @atlaskit/editor/no-re-export */
 
-export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './common/syncBlockProvider';
-export { SyncBlockStoreManager, useFetchSyncBlockData, useHandleContentChanges } from './common/syncBlockStoreManager';
-export { SyncBlockStatus } from './common/types';
-export { inMemoryFetchProvider, inMemoryWriteProvider } from './providers/inMemory';
+export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
+export { SyncBlockStoreManager } from './store-manager/syncBlockStoreManager';
+export { useFetchSyncBlockData } from './hooks/useFetchSyncBlockData';
+export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export { SyncBlockError } from './common/types';
+export { inMemoryFetchProvider, inMemoryWriteProvider } from './providers/in-memory/inMemory';
 export { getDefaultSyncBlockSchema } from './common/schema';
-export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders } from './providers/confluenceContentAPI';
+export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders } from './providers/confluence/confluenceContentAPI';
 export { getConfluencePageAri } from './utils/ari';
-export { convertSyncBlockPMNodeToSyncBlockNode as convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
+export { convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
 export { rebaseTransaction } from './common/rebase-transaction';

package/dist/es2019/providers/{confluenceContentAPI.js → confluence/confluenceContentAPI.js}

@@ -1,9 +1,9 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { useMemo } from 'react';
-import { SyncBlockStatus } from '../common/types';
-import { getLocalIdFromAri, getPageIdAndTypeFromAri } from '../utils/ari';
-import { getContentProperty, createContentProperty, updateContentProperty } from '../utils/contentProperty';
-import { isBlogPageType } from '../utils/utils';
+import { SyncBlockError } from '../../common/types';
+import { getLocalIdFromAri, getPageIdAndTypeFromAri } from '../../utils/ari';
+import { getContentProperty, createContentProperty, updateContentProperty } from '../../utils/contentProperty';
+import { isBlogPageType } from '../../utils/utils';
 
 /**
  * Configuration for Content API providers
@@ -27,16 +27,16 @@ const parseSyncedBlockContentPropertyValue = value => {
     throw new Error(`Failed to parse synced block data: ${error}`);
   }
 };
-const getResponseStatus = contentProperty => {
+const getResponseError = contentProperty => {
   var _content$properties;
   const content = 'blogPost' in contentProperty.data.confluence ? contentProperty.data.confluence.blogPost : contentProperty.data.confluence.page;
   if (!content) {
-    return SyncBlockStatus.Unauthorized;
+    return SyncBlockError.Forbidden;
   }
   if (!((_content$properties = content.properties) !== null && _content$properties !== void 0 && _content$properties[0])) {
-    return SyncBlockStatus.NotFound;
+    return SyncBlockError.NotFound;
   }
-  return SyncBlockStatus.Errored;
+  return SyncBlockError.Errored;
 };
 
 /**
@@ -60,22 +60,22 @@ class ConfluenceADFFetchProvider {
         cloudId: this.config.cloudId,
         pageType
       };
-      let status;
+      let error;
       let value;
       if (isBlogPageType(pageType)) {
         var _contentProperty$data, _contentProperty$data2, _contentProperty$data3;
         const contentProperty = await getContentProperty(options);
         value = (_contentProperty$data = contentProperty.data.confluence.blogPost) === null || _contentProperty$data === void 0 ? void 0 : (_contentProperty$data2 = _contentProperty$data.properties) === null || _contentProperty$data2 === void 0 ? void 0 : (_contentProperty$data3 = _contentProperty$data2[0]) === null || _contentProperty$data3 === void 0 ? void 0 : _contentProperty$data3.value;
-        status = getResponseStatus(contentProperty);
+        error = getResponseError(contentProperty);
       } else {
         var _contentProperty$data4, _contentProperty$data5, _contentProperty$data6;
         const contentProperty = await getContentProperty(options);
         value = (_contentProperty$data4 = contentProperty.data.confluence.page) === null || _contentProperty$data4 === void 0 ? void 0 : (_contentProperty$data5 = _contentProperty$data4.properties) === null || _contentProperty$data5 === void 0 ? void 0 : (_contentProperty$data6 = _contentProperty$data5[0]) === null || _contentProperty$data6 === void 0 ? void 0 : _contentProperty$data6.value;
-        status = getResponseStatus(contentProperty);
+        error = getResponseError(contentProperty);
       }
       if (!value) {
         return {
-          status: status,
+          error,
           resourceId
         };
       }
@@ -83,13 +83,16 @@ class ConfluenceADFFetchProvider {
       // Parse the synced block content from the property value
       const syncedBlockData = parseSyncedBlockContentPropertyValue(value);
       return {
-        content: syncedBlockData.content,
-        resourceId,
-        blockInstanceId: localId
+        data: {
+          content: syncedBlockData.content,
+          resourceId,
+          blockInstanceId: localId
+        },
+        resourceId
       };
     } catch {
       return {
-        status: SyncBlockStatus.Errored,
+        error: SyncBlockError.Errored,
         resourceId
       };
     }

package/dist/es2019/providers/{inMemory.js → in-memory/inMemory.js}

@@ -5,7 +5,10 @@ export const inMemoryFetchProvider = {
     if (!data) {
       throw new Error('Sync Block Provider (in-mem): Data not found');
     }
-    return Promise.resolve(data);
+    return Promise.resolve({
+      data,
+      resourceId
+    });
   }
 };
 export const inMemoryWriteProvider = {

package/dist/es2019/{common → providers}/syncBlockProvider.js

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { useMemo } from 'react';
+import { SyncBlockDataProvider } from '../providers/types';
 import { getLocalIdFromAri, getPageARIFromResourceId } from '../utils/ari';
-import { SyncBlockDataProvider } from './types';
 export class SyncBlockProvider extends SyncBlockDataProvider {
   constructor(fetchProvider, writeProvider, sourceId) {
     super();

package/dist/es2019/providers/types.js

@@ -0,0 +1,2 @@
+import { NodeDataProvider } from '@atlaskit/node-data-provider';
+export class SyncBlockDataProvider extends NodeDataProvider {}

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

@@ -0,0 +1,83 @@
+const createSyncBlockNode = (localId, resourceId) => {
+  return {
+    type: 'syncBlock',
+    attrs: {
+      localId,
+      resourceId
+    }
+  };
+};
+export class ReferenceSyncBlockStoreManager {
+  constructor(dataProvider) {
+    this.dataProvider = dataProvider;
+    this.syncBlockCache = new Map();
+    this.syncBlockURLRequests = new Map();
+  }
+
+  /**
+   *
+   * @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.
+   */
+  fetchSyncBlockSourceURL({
+    localId,
+    resourceId
+  }) {
+    if (!localId || !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;
+        }
+      }).finally(() => {
+        this.syncBlockURLRequests.set(localId, false);
+      });
+    }
+  }
+  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.dataProvider.fetchNodesData([syncNode]);
+    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
+      });
+    }
+    return fetchSyncBlockDataResult;
+  }
+
+  /**
+   * Get the URL for a sync block.
+   * @param localId - The local ID of the sync block to get the URL for
+   * @returns
+   */
+  getSyncBlockURL(localId) {
+    const syncBlock = this.syncBlockCache.get(localId);
+    return syncBlock === null || syncBlock === void 0 ? void 0 : syncBlock.sourceURL;
+  }
+}

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

@@ -0,0 +1,115 @@
+import uuid from 'uuid';
+import { rebaseTransaction } from '../common/rebase-transaction';
+import { resourceIdFromSourceAndLocalId } from '../utils/ari';
+import { convertSyncBlockPMNodeToSyncBlockData } from '../utils/utils';
+export class SourceSyncBlockStoreManager {
+  constructor(dataProvider) {
+    this.dataProvider = dataProvider;
+    this.syncBlockCache = new Map();
+  }
+
+  /**
+   * Add/update a sync block node to/from the local cache
+   * @param syncBlockNode - The sync block node to update
+   */
+  updateSyncBlockData(syncBlockNode) {
+    try {
+      const {
+        localId,
+        resourceId
+      } = syncBlockNode.attrs;
+      if (!localId || !resourceId) {
+        throw new Error('Local ID or resource ID is not set');
+      }
+      const syncBlockData = convertSyncBlockPMNodeToSyncBlockData(syncBlockNode);
+      this.syncBlockCache.set(localId, syncBlockData);
+    } catch {
+      //TODO: EDITOR-1921 - add error analytics
+    }
+  }
+
+  /**
+   * Save content of bodiedSyncBlock nodes in local cache to backend
+   *
+   * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+   */
+  async flushBodiedSyncBlocks() {
+    try {
+      if (!this.dataProvider) {
+        throw new Error('Data provider not set');
+      }
+      const bodiedSyncBlockNodes = [];
+      const bodiedSyncBlockData = [];
+      Array.from(this.syncBlockCache.values()).forEach(syncBlockData => {
+        bodiedSyncBlockNodes.push({
+          type: 'bodiedSyncBlock',
+          attrs: {
+            localId: syncBlockData.blockInstanceId,
+            resourceId: syncBlockData.resourceId
+          }
+        });
+        bodiedSyncBlockData.push(syncBlockData);
+      });
+      if (bodiedSyncBlockNodes.length === 0) {
+        return Promise.resolve(true);
+      }
+      const resourceIds = await this.dataProvider.writeNodesData(bodiedSyncBlockNodes, bodiedSyncBlockData);
+      return resourceIds.every(resourceId => resourceId !== undefined);
+    } catch {
+      //TODO: EDITOR-1921 - add error analytics
+      return false;
+    }
+  }
+  setEditorView(editorView) {
+    this.editorView = editorView;
+  }
+  registerConfirmationCallback(callback) {
+    this.confirmationCallback = callback;
+    return () => {
+      this.confirmationCallback = undefined;
+    };
+  }
+  requireConfirmationBeforeDelete() {
+    return !!this.confirmationCallback;
+  }
+  createSyncBlockNode() {
+    var _this$dataProvider;
+    const blockInstanceId = uuid();
+    const sourceId = (_this$dataProvider = this.dataProvider) === null || _this$dataProvider === void 0 ? void 0 : _this$dataProvider.getSourceId();
+    if (!sourceId) {
+      throw new Error('Provider of sync block plugin is not set');
+    }
+
+    // This should be generated by the data provider implementation as it differs between data providers
+    const resourceId = resourceIdFromSourceAndLocalId(sourceId, blockInstanceId);
+    const syncBlockNode = {
+      attrs: {
+        resourceId,
+        localId: blockInstanceId
+      },
+      type: 'bodiedSyncBlock'
+    };
+    return syncBlockNode;
+  }
+  async deleteSyncBlocksWithConfirmation(tr, syncBlockIds) {
+    if (this.confirmationCallback) {
+      this.confirmationTransaction = tr;
+      const confirmed = await this.confirmationCallback();
+      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));
+      }
+      this.confirmationTransaction = undefined;
+    }
+  }
+  rebaseTransaction(incomingTr, state) {
+    if (!this.confirmationTransaction) {
+      return;
+    }
+    this.confirmationTransaction = rebaseTransaction(this.confirmationTransaction, incomingTr, state);
+  }
+}

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

@@ -0,0 +1,79 @@
+import { ReferenceSyncBlockStoreManager } from './referenceSyncBlockStoreManager';
+import { SourceSyncBlockStoreManager } from './sourceSyncBlockStoreManager';
+
+// A store manager responsible for the lifecycle and state management of sync blocks in an editor instance.
+// Supports create, read, update, and delete operations for sync blocks.
+// Designed to manage local in-memory state and synchronize with an external data provider.
+// Handles caching, debouncing updates, and publish/subscribe for local changes.
+// Ensures consistency between local and remote state, and can be used in both editor and renderer contexts.
+export class SyncBlockStoreManager {
+  constructor(dataProvider) {
+    this.referenceSyncBlockStoreManager = new ReferenceSyncBlockStoreManager(dataProvider);
+    this.sourceSyncBlockStoreManager = new SourceSyncBlockStoreManager(dataProvider);
+  }
+  fetchSyncBlockData(syncBlockNode) {
+    if (this.isSourceBlock(syncBlockNode)) {
+      return Promise.reject(new Error('Invalid sync block node type provided for fetchSyncBlockData'));
+    }
+    return this.referenceSyncBlockStoreManager.fetchSyncBlockData(syncBlockNode);
+  }
+
+  /**
+   * Add/update a sync block node to/from the local cache
+   * @param syncBlockNode - The sync block node to update
+   */
+  updateSyncBlockData(syncBlockNode) {
+    if (this.isSourceBlock(syncBlockNode)) {
+      this.sourceSyncBlockStoreManager.updateSyncBlockData(syncBlockNode);
+    } else {
+      throw new Error('Invalid sync block node type provided for updateSyncBlockData');
+    }
+  }
+
+  /**
+   * Save content of bodiedSyncBlock nodes in local cache to backend
+   *
+   * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+   */
+  flushBodiedSyncBlocks() {
+    // only applicable to source sync block, for now (will be refactored further)
+    return this.sourceSyncBlockStoreManager.flushBodiedSyncBlocks();
+  }
+
+  /**
+   * Get the URL for a sync block.
+   * @param localId - The local ID of the sync block to get the URL for
+   * @returns
+   */
+  getSyncBlockURL(localId) {
+    // only applicable to reference sync block, for now (will be refactored further)
+    return this.referenceSyncBlockStoreManager.getSyncBlockURL(localId);
+  }
+  setEditorView(editorView) {
+    // only applicable to source sync block, for now (will be refactored further)
+    this.sourceSyncBlockStoreManager.setEditorView(editorView);
+  }
+  isSourceBlock(node) {
+    return node.type.name === 'bodiedSyncBlock';
+  }
+  registerConfirmationCallback(callback) {
+    // only applicable to source sync block, for now (will be refactored further)
+    return this.sourceSyncBlockStoreManager.registerConfirmationCallback(callback);
+  }
+  requireConfirmationBeforeDelete() {
+    // only applicable to source sync block, for now (will be refactored further)
+    return this.sourceSyncBlockStoreManager.requireConfirmationBeforeDelete();
+  }
+  createSyncBlockNode() {
+    // only applicable to source sync block, for now (will be refactored further)
+    return this.sourceSyncBlockStoreManager.createSyncBlockNode();
+  }
+  deleteSyncBlocksWithConfirmation(tr, syncBlockIds) {
+    // only applicable to source sync block, for now (will be refactored further)
+    return this.sourceSyncBlockStoreManager.deleteSyncBlocksWithConfirmation(tr, syncBlockIds);
+  }
+  rebaseTransaction(incomingTr, state) {
+    // only applicable to source sync block, for now (will be refactored further)
+    this.sourceSyncBlockStoreManager.rebaseTransaction(incomingTr, state);
+  }
+}

package/dist/es2019/utils/utils.js

@@ -1,16 +1,3 @@
-import { JSONTransformer } from '@atlaskit/editor-json-transformer';
-export const convertSyncBlockPMNodeToSyncBlockNode = (node, includeContent = false) => {
-  const transformer = new JSONTransformer();
-  const toJSON = node => transformer.encodeNode(node);
-  return {
-    type: node.type.name === 'bodiedSyncBlock' ? 'bodiedSyncBlock' : 'syncBlock',
-    attrs: {
-      localId: node.attrs.localId,
-      resourceId: node.attrs.resourceId
-    },
-    content: includeContent ? node.content.content.map(toJSON) : undefined
-  };
-};
 export const convertSyncBlockPMNodeToSyncBlockData = node => {
   return {
     blockInstanceId: node.attrs.localId,

package/dist/esm/common/types.js

@@ -1,22 +1,6 @@
-import _createClass from "@babel/runtime/helpers/createClass";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-import { NodeDataProvider } from '@atlaskit/node-data-provider';
-export var SyncBlockStatus = /*#__PURE__*/function (SyncBlockStatus) {
-  SyncBlockStatus["Errored"] = "errored";
-  SyncBlockStatus["NotFound"] = "not_found";
-  SyncBlockStatus["Unauthorized"] = "unauthorized";
-  return SyncBlockStatus;
-}({});
-export var SyncBlockDataProvider = /*#__PURE__*/function (_NodeDataProvider) {
-  function SyncBlockDataProvider() {
-    _classCallCheck(this, SyncBlockDataProvider);
-    return _callSuper(this, SyncBlockDataProvider, arguments);
-  }
-  _inherits(SyncBlockDataProvider, _NodeDataProvider);
-  return _createClass(SyncBlockDataProvider);
-}(NodeDataProvider);
+export var SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
+  SyncBlockError["Errored"] = "errored";
+  SyncBlockError["NotFound"] = "not_found";
+  SyncBlockError["Forbidden"] = "forbidden";
+  return SyncBlockError;
+}({});