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

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

@@ -1,52 +1,21 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { resolveFetchSyncBlockDataResult } from '../utils/mergeFetchSyncBlockDataResult';
-const createSyncBlockNode = (localId, resourceId) => {
-  return {
-    type: 'syncBlock',
-    attrs: {
-      localId,
-      resourceId
-    }
-  };
-};
+import { createSyncBlockNode } from '../utils/createSyncBlock';
+import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 export class ReferenceSyncBlockStoreManager {
   constructor(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;
-  }
 
   /**
    * Refreshes the subscriptions for all sync blocks.
    * @returns {Promise<void>}
    */
   async refreshSubscriptions() {
-    if (this.isRefreshingSubscriptions || !this.isInitialized) {
+    if (this.isRefreshingSubscriptions) {
       return;
     }
     this.isRefreshingSubscriptions = true;
@@ -89,23 +58,6 @@ export class ReferenceSyncBlockStoreManager {
       });
     }
   }
-
-  /**
-   * 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);
-    const data = await this.fetchSyncBlocksData([syncNode]);
-    if (!data || data.length === 0) {
-      throw new Error('Failed to fetch sync block data');
-    }
-    return data[0];
-  }
   async fetchSyncBlocksData(syncBlockNodes) {
     if (!this.dataProvider) {
       throw new Error('Data provider not set');
@@ -115,19 +67,19 @@ export class ReferenceSyncBlockStoreManager {
       throw new Error('Failed to fetch sync block node data');
     }
     const resolvedData = [];
-    data.forEach(fetchSyncBlockDataResult => {
-      var _resolvedFetchSyncBlo;
-      if (!fetchSyncBlockDataResult.resourceId) {
+    data.forEach(syncBlockInstance => {
+      var _resolvedSyncBlockIns;
+      if (!syncBlockInstance.resourceId) {
         return;
       }
-      const existingSyncBlock = this.getFromCache(fetchSyncBlockDataResult.resourceId);
-      const resolvedFetchSyncBlockDataResult = existingSyncBlock ? resolveFetchSyncBlockDataResult(existingSyncBlock, fetchSyncBlockDataResult) : fetchSyncBlockDataResult;
-      this.updateCache(resolvedFetchSyncBlockDataResult);
-      resolvedData.push(resolvedFetchSyncBlockDataResult);
+      const existingSyncBlock = this.getFromCache(syncBlockInstance.resourceId);
+      const resolvedSyncBlockInstance = existingSyncBlock ? resolveSyncBlockInstance(existingSyncBlock, syncBlockInstance) : syncBlockInstance;
+      this.updateCache(resolvedSyncBlockInstance);
+      resolvedData.push(resolvedSyncBlockInstance);
 
       // fetch source URL if not already present
-      if (!((_resolvedFetchSyncBlo = resolvedFetchSyncBlockDataResult.data) !== null && _resolvedFetchSyncBlo !== void 0 && _resolvedFetchSyncBlo.sourceURL) && resolvedFetchSyncBlockDataResult.resourceId) {
-        this.fetchSyncBlockSourceURL(resolvedFetchSyncBlockDataResult.resourceId);
+      if (!((_resolvedSyncBlockIns = resolvedSyncBlockInstance.data) !== null && _resolvedSyncBlockIns !== void 0 && _resolvedSyncBlockIns.sourceURL) && resolvedSyncBlockInstance.resourceId) {
+        this.fetchSyncBlockSourceURL(resolvedSyncBlockInstance.resourceId);
       }
     });
     return resolvedData;
@@ -177,7 +129,7 @@ export class ReferenceSyncBlockStoreManager {
     if (cachedData) {
       callback(cachedData);
     } else {
-      this.fetchSyncBlockData(node).catch(() => {});
+      this.fetchSyncBlocksData([createSyncBlockNode(localId, resourceId)]).catch(() => {});
     }
     return () => {
       const resourceSubscriptions = this.subscriptions.get(resourceId);
@@ -210,7 +162,5 @@ export class ReferenceSyncBlockStoreManager {
     this.syncBlockCache.clear();
     this.subscriptions.clear();
     this.syncBlockURLRequests.clear();
-    this.editorView = undefined;
-    this.isInitialized = false;
   }
 }

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

@@ -1,3 +1,4 @@
+import { createSyncBlockNode } from '../utils/createSyncBlock';
 import { ReferenceSyncBlockStoreManager } from './referenceSyncBlockStoreManager';
 import { SourceSyncBlockStoreManager } from './sourceSyncBlockStoreManager';
 
@@ -13,18 +14,20 @@ export class SyncBlockStoreManager {
   }
 
   /**
-   * 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
+   * Fetch sync block data for a given array of sync block nodes.
+   * @param nodes - The array of sync block nodes to fetch data for
+   * @returns The fetched sync block data results
    */
-  fetchSyncBlockData(syncBlockNode) {
-    if (!['bodiedSyncBlock', 'syncBlock'].includes(syncBlockNode.type.name)) {
-      throw new Error('Node is not a sync block');
+  fetchSyncBlocksData(nodes) {
+    const syncBlockNodes = nodes.filter(node => {
+      return node.type.name === 'syncBlock' && node.attrs.resourceId && node.attrs.localId;
+    }).map(node => {
+      return createSyncBlockNode(node.attrs.localId, node.attrs.resourceId);
+    }) || [];
+    if (syncBlockNodes.length === 0) {
+      return Promise.resolve([]);
     }
-    if (this.isSourceBlock(syncBlockNode)) {
-      return Promise.reject(new Error('Invalid sync block node type provided for fetchSyncBlockData'));
-    }
-    return this.referenceSyncBlockStoreManager.fetchSyncBlockData(syncBlockNode);
+    return this.referenceSyncBlockStoreManager.fetchSyncBlocksData(syncBlockNodes);
   }
 
   /**
@@ -60,9 +63,6 @@ export class SyncBlockStoreManager {
   }
   setEditorView(editorView) {
     this.sourceSyncBlockStoreManager.setEditorView(editorView);
-    if (editorView) {
-      this.referenceSyncBlockStoreManager.init(editorView);
-    }
   }
   isSourceBlock(node) {
     return node.type.name === 'bodiedSyncBlock';

package/dist/es2019/utils/createSyncBlock.js

@@ -0,0 +1,9 @@
+export const createSyncBlockNode = (localId, resourceId) => {
+  return {
+    type: 'syncBlock',
+    attrs: {
+      localId,
+      resourceId
+    }
+  };
+};

package/dist/es2019/utils/{mergeFetchSyncBlockDataResult.js → resolveSyncBlockInstance.js}

@@ -1,14 +1,14 @@
 /**
- * Merges two FetchSyncBlockDataResult objects,
+ * Merges two SyncBlockInstance 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.
+ * @param oldResult - The existing SyncBlockInstance object.
+ * @param newResult - The new SyncBlockInstance object to merge.
+ * @returns A merged SyncBlockInstance object.
  */
-export const resolveFetchSyncBlockDataResult = (oldResult, newResult) => {
+export const resolveSyncBlockInstance = (oldResult, newResult) => {
   var _newResult$data, _oldResult$data;
   // if the old result has no data, we simple return the new result
   if (!oldResult.data) {

package/dist/esm/hooks/useFetchSyncBlockData.js

@@ -4,15 +4,15 @@ export var SYNC_BLOCK_FETCH_INTERVAL = 3000;
 export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, syncBlockNode) {
   var _useState = useState(null),
     _useState2 = _slicedToArray(_useState, 2),
-    fetchSyncBlockDataResult = _useState2[0],
-    setFetchSyncBlockDataResult = _useState2[1];
+    syncBlockInstance = _useState2[0],
+    setSyncBlockInstance = _useState2[1];
   useEffect(function () {
     var unsubscribe = manager.subscribeToSyncBlockData(syncBlockNode, function (data) {
-      setFetchSyncBlockDataResult(data);
+      setSyncBlockInstance(data);
     });
     return function () {
       unsubscribe();
     };
-  }, [manager, setFetchSyncBlockDataResult, syncBlockNode]);
-  return fetchSyncBlockDataResult;
+  }, [manager, syncBlockNode]);
+  return syncBlockInstance;
 };

package/dist/esm/index.js

@@ -5,9 +5,9 @@ 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/confluence/confluenceContentAPI';
 export { getConfluencePageAri } from './utils/ari';
 export { convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
-export { rebaseTransaction } from './common/rebase-transaction';
+export { rebaseTransaction } from './common/rebase-transaction';
+export { resolveSyncBlockInstance } from './utils/resolveSyncBlockInstance';

package/dist/esm/providers/types.js

@@ -6,6 +6,13 @@ 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';
+
+/**
+ * The instance of a sync block, containing its data and metadata.
+ * Mainly used for representing the state of a sync block after fetching from a data provider.
+ * This will be used in both data processing and rendering contexts.
+ */
+
 export var SyncBlockDataProvider = /*#__PURE__*/function (_NodeDataProvider) {
   function SyncBlockDataProvider() {
     _classCallCheck(this, SyncBlockDataProvider);

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

@@ -5,111 +5,48 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@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) { _defineProperty(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; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { resolveFetchSyncBlockDataResult } from '../utils/mergeFetchSyncBlockDataResult';
-var createSyncBlockNode = function createSyncBlockNode(localId, resourceId) {
-  return {
-    type: 'syncBlock',
-    attrs: {
-      localId: localId,
-      resourceId: resourceId
-    }
-  };
-};
+import { createSyncBlockNode } from '../utils/createSyncBlock';
+import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
   function ReferenceSyncBlockStoreManager(dataProvider) {
     _classCallCheck(this, ReferenceSyncBlockStoreManager);
-    _defineProperty(this, "isInitialized", false);
     _defineProperty(this, "isRefreshingSubscriptions", false);
     this.syncBlockCache = new Map();
     this.subscriptions = new Map();
     this.dataProvider = dataProvider;
     this.syncBlockURLRequests = new Map();
   }
+
+  /**
+   * Refreshes the subscriptions for all sync blocks.
+   * @returns {Promise<void>}
+   */
   return _createClass(ReferenceSyncBlockStoreManager, [{
-    key: "init",
-    value: function () {
-      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(editorView) {
-        var _this = this;
-        var syncBlockNodes, dataResults;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              if (!(!this.editorView && !this.isInitialized)) {
-                _context.next = 15;
-                break;
-              }
-              this.editorView = editorView;
-              syncBlockNodes = editorView.state.doc.children.filter(function (node) {
-                return node.type.name === 'syncBlock';
-              }).map(function (node) {
-                return node.toJSON();
-              }) || [];
-              if (!(syncBlockNodes.length > 0)) {
-                _context.next = 15;
-                break;
-              }
-              _context.prev = 4;
-              _context.next = 7;
-              return this.fetchSyncBlocksData(syncBlockNodes);
-            case 7:
-              dataResults = _context.sent;
-              if (dataResults) {
-                _context.next = 10;
-                break;
-              }
-              throw new Error('No data results returned when initializing sync block store manager');
-            case 10:
-              dataResults.forEach(function (dataResult) {
-                _this.updateCache(dataResult);
-              });
-              _context.next = 15;
-              break;
-            case 13:
-              _context.prev = 13;
-              _context.t0 = _context["catch"](4);
-            case 15:
-              this.isInitialized = true;
-            case 16:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[4, 13]]);
-      }));
-      function init(_x) {
-        return _init.apply(this, arguments);
-      }
-      return init;
-    }()
-    /**
-     * Refreshes the subscriptions for all sync blocks.
-     * @returns {Promise<void>}
-     */
-  }, {
     key: "refreshSubscriptions",
     value: (function () {
-      var _refreshSubscriptions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _refreshSubscriptions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
         var syncBlocks, _iterator, _step, _loop;
-        return _regeneratorRuntime.wrap(function _callee2$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+        return _regeneratorRuntime.wrap(function _callee$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              if (!(this.isRefreshingSubscriptions || !this.isInitialized)) {
-                _context3.next = 2;
+              if (!this.isRefreshingSubscriptions) {
+                _context2.next = 2;
                 break;
               }
-              return _context3.abrupt("return");
+              return _context2.abrupt("return");
             case 2:
               this.isRefreshingSubscriptions = true;
               syncBlocks = [];
               _iterator = _createForOfIteratorHelper(this.subscriptions.entries());
-              _context3.prev = 5;
+              _context2.prev = 5;
               _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
                 var _step$value, resourceId, callbacks;
-                return _regeneratorRuntime.wrap(function _loop$(_context2) {
-                  while (1) switch (_context2.prev = _context2.next) {
+                return _regeneratorRuntime.wrap(function _loop$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
                     case 0:
                       _step$value = _slicedToArray(_step.value, 2), resourceId = _step$value[0], callbacks = _step$value[1];
                       Object.keys(callbacks).forEach(function (localId) {
@@ -117,50 +54,50 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
                       });
                     case 2:
                     case "end":
-                      return _context2.stop();
+                      return _context.stop();
                   }
                 }, _loop);
               });
               _iterator.s();
             case 8:
               if ((_step = _iterator.n()).done) {
-                _context3.next = 12;
+                _context2.next = 12;
                 break;
               }
-              return _context3.delegateYield(_loop(), "t0", 10);
+              return _context2.delegateYield(_loop(), "t0", 10);
             case 10:
-              _context3.next = 8;
+              _context2.next = 8;
               break;
             case 12:
-              _context3.next = 17;
+              _context2.next = 17;
               break;
             case 14:
-              _context3.prev = 14;
-              _context3.t1 = _context3["catch"](5);
-              _iterator.e(_context3.t1);
+              _context2.prev = 14;
+              _context2.t1 = _context2["catch"](5);
+              _iterator.e(_context2.t1);
             case 17:
-              _context3.prev = 17;
+              _context2.prev = 17;
               _iterator.f();
-              return _context3.finish(17);
+              return _context2.finish(17);
             case 20:
-              _context3.prev = 20;
-              _context3.next = 23;
+              _context2.prev = 20;
+              _context2.next = 23;
               return this.fetchSyncBlocksData(syncBlocks);
             case 23:
-              _context3.next = 27;
+              _context2.next = 27;
               break;
             case 25:
-              _context3.prev = 25;
-              _context3.t2 = _context3["catch"](20);
+              _context2.prev = 25;
+              _context2.t2 = _context2["catch"](20);
             case 27:
-              _context3.prev = 27;
+              _context2.prev = 27;
               this.isRefreshingSubscriptions = false;
-              return _context3.finish(27);
+              return _context2.finish(27);
             case 30:
             case "end":
-              return _context3.stop();
+              return _context2.stop();
           }
-        }, _callee2, this, [[5, 14, 17, 20], [20, 25, 27, 30]]);
+        }, _callee, this, [[5, 14, 17, 20], [20, 25, 27, 30]]);
       }));
       function refreshSubscriptions() {
         return _refreshSubscriptions.apply(this, arguments);
@@ -170,7 +107,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
   }, {
     key: "fetchSyncBlockSourceURL",
     value: function fetchSyncBlockSourceURL(resourceId) {
-      var _this2 = this;
+      var _this = this;
       if (!resourceId || !this.dataProvider) {
         return;
       }
@@ -180,110 +117,67 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       if (!this.syncBlockURLRequests.get(resourceId)) {
         this.syncBlockURLRequests.set(resourceId, true);
         this.dataProvider.retrieveSyncBlockSourceUrl(createSyncBlockNode('', resourceId)).then(function (sourceURL) {
-          var existingSyncBlock = _this2.getFromCache(resourceId);
+          var existingSyncBlock = _this.getFromCache(resourceId);
           if (existingSyncBlock && existingSyncBlock.data) {
             existingSyncBlock.data = _objectSpread(_objectSpread({}, existingSyncBlock.data), {}, {
               sourceURL: sourceURL
             });
-            _this2.updateCache(existingSyncBlock);
+            _this.updateCache(existingSyncBlock);
           }
         }).finally(function () {
-          _this2.syncBlockURLRequests.set(resourceId, 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
-     */
-  }, {
-    key: "fetchSyncBlockData",
-    value: (function () {
-      var _fetchSyncBlockData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(syncBlockNode) {
-        var syncNode, data;
-        return _regeneratorRuntime.wrap(function _callee3$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              if (this.dataProvider) {
-                _context4.next = 2;
-                break;
-              }
-              throw new Error('Data provider not set');
-            case 2:
-              syncNode = createSyncBlockNode(syncBlockNode.attrs.localId, syncBlockNode.attrs.resourceId);
-              _context4.next = 5;
-              return this.fetchSyncBlocksData([syncNode]);
-            case 5:
-              data = _context4.sent;
-              if (!(!data || data.length === 0)) {
-                _context4.next = 8;
-                break;
-              }
-              throw new Error('Failed to fetch sync block data');
-            case 8:
-              return _context4.abrupt("return", data[0]);
-            case 9:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee3, this);
-      }));
-      function fetchSyncBlockData(_x2) {
-        return _fetchSyncBlockData.apply(this, arguments);
-      }
-      return fetchSyncBlockData;
-    }())
   }, {
     key: "fetchSyncBlocksData",
     value: function () {
-      var _fetchSyncBlocksData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(syncBlockNodes) {
-        var _this3 = this;
+      var _fetchSyncBlocksData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(syncBlockNodes) {
+        var _this2 = this;
         var data, resolvedData;
-        return _regeneratorRuntime.wrap(function _callee4$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+        return _regeneratorRuntime.wrap(function _callee2$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
               if (this.dataProvider) {
-                _context5.next = 2;
+                _context3.next = 2;
                 break;
               }
               throw new Error('Data provider not set');
             case 2:
-              _context5.next = 4;
+              _context3.next = 4;
               return this.dataProvider.fetchNodesData(syncBlockNodes);
             case 4:
-              data = _context5.sent;
+              data = _context3.sent;
               if (data) {
-                _context5.next = 7;
+                _context3.next = 7;
                 break;
               }
               throw new Error('Failed to fetch sync block node data');
             case 7:
               resolvedData = [];
-              data.forEach(function (fetchSyncBlockDataResult) {
-                var _resolvedFetchSyncBlo;
-                if (!fetchSyncBlockDataResult.resourceId) {
+              data.forEach(function (syncBlockInstance) {
+                var _resolvedSyncBlockIns;
+                if (!syncBlockInstance.resourceId) {
                   return;
                 }
-                var existingSyncBlock = _this3.getFromCache(fetchSyncBlockDataResult.resourceId);
-                var resolvedFetchSyncBlockDataResult = existingSyncBlock ? resolveFetchSyncBlockDataResult(existingSyncBlock, fetchSyncBlockDataResult) : fetchSyncBlockDataResult;
-                _this3.updateCache(resolvedFetchSyncBlockDataResult);
-                resolvedData.push(resolvedFetchSyncBlockDataResult);
+                var existingSyncBlock = _this2.getFromCache(syncBlockInstance.resourceId);
+                var resolvedSyncBlockInstance = existingSyncBlock ? resolveSyncBlockInstance(existingSyncBlock, syncBlockInstance) : syncBlockInstance;
+                _this2.updateCache(resolvedSyncBlockInstance);
+                resolvedData.push(resolvedSyncBlockInstance);
 
                 // fetch source URL if not already present
-                if (!((_resolvedFetchSyncBlo = resolvedFetchSyncBlockDataResult.data) !== null && _resolvedFetchSyncBlo !== void 0 && _resolvedFetchSyncBlo.sourceURL) && resolvedFetchSyncBlockDataResult.resourceId) {
-                  _this3.fetchSyncBlockSourceURL(resolvedFetchSyncBlockDataResult.resourceId);
+                if (!((_resolvedSyncBlockIns = resolvedSyncBlockInstance.data) !== null && _resolvedSyncBlockIns !== void 0 && _resolvedSyncBlockIns.sourceURL) && resolvedSyncBlockInstance.resourceId) {
+                  _this2.fetchSyncBlockSourceURL(resolvedSyncBlockInstance.resourceId);
                 }
               });
-              return _context5.abrupt("return", resolvedData);
+              return _context3.abrupt("return", resolvedData);
             case 10:
             case "end":
-              return _context5.stop();
+              return _context3.stop();
           }
-        }, _callee4, this);
+        }, _callee2, this);
       }));
-      function fetchSyncBlocksData(_x3) {
+      function fetchSyncBlocksData(_x) {
         return _fetchSyncBlocksData.apply(this, arguments);
       }
       return fetchSyncBlocksData;
@@ -315,7 +209,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
   }, {
     key: "subscribe",
     value: function subscribe(node, callback) {
-      var _this4 = this;
+      var _this3 = this;
       // check node is a sync block, as we only support sync block subscriptions
       if (node.type.name !== 'syncBlock') {
         return function () {};
@@ -336,17 +230,17 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       if (cachedData) {
         callback(cachedData);
       } else {
-        this.fetchSyncBlockData(node).catch(function () {});
+        this.fetchSyncBlocksData([createSyncBlockNode(localId, resourceId)]).catch(function () {});
       }
       return function () {
-        var resourceSubscriptions = _this4.subscriptions.get(resourceId);
+        var resourceSubscriptions = _this3.subscriptions.get(resourceId);
         if (resourceSubscriptions) {
           delete resourceSubscriptions[localId];
           if (Object.keys(resourceSubscriptions).length === 0) {
-            _this4.subscriptions.delete(resourceId);
-            _this4.deleteFromCache(resourceId);
+            _this3.subscriptions.delete(resourceId);
+            _this3.deleteFromCache(resourceId);
           } else {
-            _this4.subscriptions.set(resourceId, resourceSubscriptions);
+            _this3.subscriptions.set(resourceId, resourceSubscriptions);
           }
         }
       };
@@ -373,8 +267,6 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       this.syncBlockCache.clear();
       this.subscriptions.clear();
       this.syncBlockURLRequests.clear();
-      this.editorView = undefined;
-      this.isInitialized = false;
     }
   }]);
 }();