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

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/editor-synced-block-provider
 
+## 2.5.0
+
+### Minor Changes
+
+- [`424619eee38cb`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/424619eee38cb) -
+  EDITOR-2451 add tests and refactor
+
+### Patch Changes
+
+- Updated dependencies
+
+## 2.4.0
+
+### Minor Changes
+
+- [`7d9f7451809ce`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/7d9f7451809ce) -
+  [EDITOR-2481] Move in memory write/fetch provider to @af/editor-examples-helpers/utils
+
 ## 2.3.1
 
 ### Patch Changes

package/dist/cjs/hooks/useFetchSyncBlockData.js

@@ -11,15 +11,15 @@ var SYNC_BLOCK_FETCH_INTERVAL = exports.SYNC_BLOCK_FETCH_INTERVAL = 3000;
 var useFetchSyncBlockData = exports.useFetchSyncBlockData = function useFetchSyncBlockData(manager, syncBlockNode) {
   var _useState = (0, _react.useState)(null),
     _useState2 = (0, _slicedToArray2.default)(_useState, 2),
-    fetchSyncBlockDataResult = _useState2[0],
-    setFetchSyncBlockDataResult = _useState2[1];
+    syncBlockInstance = _useState2[0],
+    setSyncBlockInstance = _useState2[1];
   (0, _react.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/cjs/index.js

@@ -45,22 +45,16 @@ Object.defineProperty(exports, "getDefaultSyncBlockSchema", {
     return _schema.getDefaultSyncBlockSchema;
   }
 });
-Object.defineProperty(exports, "inMemoryFetchProvider", {
-  enumerable: true,
-  get: function get() {
-    return _inMemory.inMemoryFetchProvider;
-  }
-});
-Object.defineProperty(exports, "inMemoryWriteProvider", {
+Object.defineProperty(exports, "rebaseTransaction", {
   enumerable: true,
   get: function get() {
-    return _inMemory.inMemoryWriteProvider;
+    return _rebaseTransaction.rebaseTransaction;
   }
 });
-Object.defineProperty(exports, "rebaseTransaction", {
+Object.defineProperty(exports, "resolveSyncBlockInstance", {
   enumerable: true,
   get: function get() {
-    return _rebaseTransaction.rebaseTransaction;
+    return _resolveSyncBlockInstance.resolveSyncBlockInstance;
   }
 });
 Object.defineProperty(exports, "useFetchSyncBlockData", {
@@ -92,9 +86,9 @@ var _syncBlockStoreManager = require("./store-manager/syncBlockStoreManager");
 var _useFetchSyncBlockData = require("./hooks/useFetchSyncBlockData");
 var _useHandleContentChanges = require("./hooks/useHandleContentChanges");
 var _types = require("./common/types");
-var _inMemory = require("./providers/in-memory/inMemory");
 var _schema = require("./common/schema");
 var _confluenceContentAPI = require("./providers/confluence/confluenceContentAPI");
 var _ari = require("./utils/ari");
 var _utils = require("./utils/utils");
-var _rebaseTransaction = require("./common/rebase-transaction");
+var _rebaseTransaction = require("./common/rebase-transaction");
+var _resolveSyncBlockInstance = require("./utils/resolveSyncBlockInstance");

package/dist/cjs/providers/types.js

@@ -13,6 +13,11 @@ var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits
 var _nodeDataProvider = require("@atlaskit/node-data-provider");
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(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; })(); }
+/**
+ * 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.
+ */
 var SyncBlockDataProvider = exports.SyncBlockDataProvider = /*#__PURE__*/function (_NodeDataProvider) {
   function SyncBlockDataProvider() {
     (0, _classCallCheck2.default)(this, SyncBlockDataProvider);

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

@@ -11,163 +11,100 @@ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _mergeFetchSyncBlockDataResult = require("../utils/mergeFetchSyncBlockDataResult");
+var _createSyncBlock = require("../utils/createSyncBlock");
+var _resolveSyncBlockInstance = require("../utils/resolveSyncBlockInstance");
 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; }
 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; }
-var createSyncBlockNode = function createSyncBlockNode(localId, resourceId) {
-  return {
-    type: 'syncBlock',
-    attrs: {
-      localId: localId,
-      resourceId: resourceId
-    }
-  };
-};
 var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
   function ReferenceSyncBlockStoreManager(dataProvider) {
     (0, _classCallCheck2.default)(this, ReferenceSyncBlockStoreManager);
-    (0, _defineProperty2.default)(this, "isInitialized", false);
     (0, _defineProperty2.default)(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 (0, _createClass2.default)(ReferenceSyncBlockStoreManager, [{
-    key: "init",
-    value: function () {
-      var _init = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(editorView) {
-        var _this = this;
-        var syncBlockNodes, dataResults;
-        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var _refreshSubscriptions = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
         var syncBlocks, _iterator, _step, _loop;
-        return _regenerator.default.wrap(function _callee2$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
+        return _regenerator.default.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__*/_regenerator.default.mark(function _loop() {
                 var _step$value, resourceId, callbacks;
-                return _regenerator.default.wrap(function _loop$(_context2) {
-                  while (1) switch (_context2.prev = _context2.next) {
+                return _regenerator.default.wrap(function _loop$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
                     case 0:
                       _step$value = (0, _slicedToArray2.default)(_step.value, 2), resourceId = _step$value[0], callbacks = _step$value[1];
                       Object.keys(callbacks).forEach(function (localId) {
-                        syncBlocks.push(createSyncBlockNode(localId, resourceId));
+                        syncBlocks.push((0, _createSyncBlock.createSyncBlockNode)(localId, resourceId));
                       });
                     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);
@@ -177,7 +114,7 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
   }, {
     key: "fetchSyncBlockSourceURL",
     value: function fetchSyncBlockSourceURL(resourceId) {
-      var _this2 = this;
+      var _this = this;
       if (!resourceId || !this.dataProvider) {
         return;
       }
@@ -186,111 +123,68 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
       // we could optimise this further by checking if the sync block is on the same page as the source
       if (!this.syncBlockURLRequests.get(resourceId)) {
         this.syncBlockURLRequests.set(resourceId, true);
-        this.dataProvider.retrieveSyncBlockSourceUrl(createSyncBlockNode('', resourceId)).then(function (sourceURL) {
-          var existingSyncBlock = _this2.getFromCache(resourceId);
+        this.dataProvider.retrieveSyncBlockSourceUrl((0, _createSyncBlock.createSyncBlockNode)('', resourceId)).then(function (sourceURL) {
+          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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(syncBlockNode) {
-        var syncNode, data;
-        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(syncBlockNodes) {
-        var _this3 = this;
+      var _fetchSyncBlocksData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(syncBlockNodes) {
+        var _this2 = this;
         var data, resolvedData;
-        return _regenerator.default.wrap(function _callee4$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+        return _regenerator.default.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 ? (0, _mergeFetchSyncBlockDataResult.resolveFetchSyncBlockDataResult)(existingSyncBlock, fetchSyncBlockDataResult) : fetchSyncBlockDataResult;
-                _this3.updateCache(resolvedFetchSyncBlockDataResult);
-                resolvedData.push(resolvedFetchSyncBlockDataResult);
+                var existingSyncBlock = _this2.getFromCache(syncBlockInstance.resourceId);
+                var resolvedSyncBlockInstance = existingSyncBlock ? (0, _resolveSyncBlockInstance.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;
@@ -322,7 +216,7 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
   }, {
     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 () {};
@@ -343,17 +237,17 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
       if (cachedData) {
         callback(cachedData);
       } else {
-        this.fetchSyncBlockData(node).catch(function () {});
+        this.fetchSyncBlocksData([(0, _createSyncBlock.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);
           }
         }
       };
@@ -380,8 +274,6 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
       this.syncBlockCache.clear();
       this.subscriptions.clear();
       this.syncBlockURLRequests.clear();
-      this.editorView = undefined;
-      this.isInitialized = false;
     }
   }]);
 }();

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.SyncBlockStoreManager = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _createSyncBlock = require("../utils/createSyncBlock");
 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.
@@ -22,20 +23,22 @@ var SyncBlockStoreManager = exports.SyncBlockStoreManager = /*#__PURE__*/functio
   }
 
   /**
-   * 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
    */
   return (0, _createClass2.default)(SyncBlockStoreManager, [{
-    key: "fetchSyncBlockData",
-    value: function fetchSyncBlockData(syncBlockNode) {
-      if (!['bodiedSyncBlock', 'syncBlock'].includes(syncBlockNode.type.name)) {
-        throw new Error('Node is not a sync block');
+    key: "fetchSyncBlocksData",
+    value: function fetchSyncBlocksData(nodes) {
+      var syncBlockNodes = nodes.filter(function (node) {
+        return node.type.name === 'syncBlock' && node.attrs.resourceId && node.attrs.localId;
+      }).map(function (node) {
+        return (0, _createSyncBlock.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);
     }
 
     /**
@@ -79,9 +82,6 @@ var SyncBlockStoreManager = exports.SyncBlockStoreManager = /*#__PURE__*/functio
     key: "setEditorView",
     value: function setEditorView(editorView) {
       this.sourceSyncBlockStoreManager.setEditorView(editorView);
-      if (editorView) {
-        this.referenceSyncBlockStoreManager.init(editorView);
-      }
     }
   }, {
     key: "isSourceBlock",

package/dist/cjs/utils/createSyncBlock.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSyncBlockNode = void 0;
+var createSyncBlockNode = exports.createSyncBlockNode = function createSyncBlockNode(localId, resourceId) {
+  return {
+    type: 'syncBlock',
+    attrs: {
+      localId: localId,
+      resourceId: resourceId
+    }
+  };
+};

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

@@ -4,21 +4,21 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.resolveFetchSyncBlockDataResult = void 0;
+exports.resolveSyncBlockInstance = 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,
+ * 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.
  */
-var resolveFetchSyncBlockDataResult = exports.resolveFetchSyncBlockDataResult = function resolveFetchSyncBlockDataResult(oldResult, newResult) {
+var resolveSyncBlockInstance = exports.resolveSyncBlockInstance = function 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/es2019/hooks/useFetchSyncBlockData.js

@@ -1,14 +1,14 @@
 import { useEffect, useState } from 'react';
 export const SYNC_BLOCK_FETCH_INTERVAL = 3000;
 export const useFetchSyncBlockData = (manager, syncBlockNode) => {
-  const [fetchSyncBlockDataResult, setFetchSyncBlockDataResult] = useState(null);
+  const [syncBlockInstance, setSyncBlockInstance] = useState(null);
   useEffect(() => {
     const unsubscribe = manager.subscribeToSyncBlockData(syncBlockNode, data => {
-      setFetchSyncBlockDataResult(data);
+      setSyncBlockInstance(data);
     });
     return () => {
       unsubscribe();
     };
-  }, [manager, setFetchSyncBlockDataResult, syncBlockNode]);
-  return fetchSyncBlockDataResult;
+  }, [manager, syncBlockNode]);
+  return syncBlockInstance;
 };

package/dist/es2019/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/es2019/providers/types.js

@@ -1,2 +1,9 @@
 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 class SyncBlockDataProvider extends NodeDataProvider {}