@atlaskit/node-data-provider 4.3.0 → 4.4.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/node-data-provider
 
+## 4.4.0
+
+### Minor Changes
+
+- [#191942](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/191942)
+  [`6b5ec599e6dfd`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/6b5ec599e6dfd) -
+  [https://product-fabric.atlassian.net/browse/ED-28596](ED-28596) - extend EditorCardProvider from
+  NodeDataProvider
+
+### Patch Changes
+
+- [#191913](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/191913)
+  [`6d1e56695e91d`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/6d1e56695e91d) -
+  EDITOR-1131 Bump adf-schema package to 50.0.0
+- Updated dependencies
+
 ## 4.3.0
 
 ### Minor Changes

package/dist/cjs/node-data-provider.js

@@ -34,6 +34,10 @@ var _coreUtils = require("@atlaskit/editor-common/core-utils");
  *   'node-id-2': { source: 'network', data: Promise.resolve({ value: 'other data' }) }
  * }
  */
+/**
+ * Represents the payload passed to the callback function when data is fetched.
+ * It can either contain an error or the fetched data.
+ */
 /**
  * A Node Data Provider is responsible for fetching and caching data associated with specific ProseMirror nodes.
  * It supports a cache-first-then-network strategy, with initial data potentially provided via SSR.
@@ -66,16 +70,15 @@ var NodeDataProvider = exports.NodeDataProvider = /*#__PURE__*/function () {
     value: function setSSRData() {
       var ssrData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       this.cacheVersion++;
-      this.cache = Object.entries(ssrData).reduce(function (acc, _ref) {
+      this.cache = Object.fromEntries(Object.entries(ssrData).map(function (_ref) {
         var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
           key = _ref2[0],
           data = _ref2[1];
-        acc[key] = {
-          source: 'ssr',
-          data: data
-        };
-        return acc;
-      }, {});
+        return [key, {
+          data: data,
+          source: 'ssr'
+        }];
+      }));
     }
 
     /**
@@ -120,7 +123,7 @@ var NodeDataProvider = exports.NodeDataProvider = /*#__PURE__*/function () {
      * ```
      *
      * @param node The node (or its ProseMirror representation) for which to fetch data.
-     * @param callback The function to call when data is available.
+     * @param callback The callback function to call with the fetched data or an error.
      */
   }, {
     key: "getData",
@@ -133,48 +136,54 @@ var NodeDataProvider = exports.NodeDataProvider = /*#__PURE__*/function () {
     key: "getDataAsync",
     value: function () {
       var _getDataAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(node, callback) {
-        var jsonNode, dataKey, dataFromCache, cacheVersionBeforeRequest, dataPromise, data;
+        var jsonNode, _dataKey, dataFromCache, cacheVersionBeforeRequest, dataPromise, data;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
+              _context.prev = 0;
               jsonNode = 'toJSON' in node ? node.toJSON() : node;
               if (this.isNodeSupported(jsonNode)) {
-                _context.next = 4;
+                _context.next = 5;
                 break;
               }
               // eslint-disable-next-line no-console
               console.error("The ".concat(this.constructor.name, " doesn't support Node ").concat(jsonNode.type, "."));
               return _context.abrupt("return");
-            case 4:
-              dataKey = this.nodeDataKey(jsonNode);
-              dataFromCache = this.cache[dataKey];
+            case 5:
+              _dataKey = this.nodeDataKey(jsonNode);
+              dataFromCache = this.cache[_dataKey];
               if (!(dataFromCache !== undefined)) {
-                _context.next = 18;
+                _context.next = 20;
                 break;
               }
               if (!isPromise(dataFromCache.data)) {
-                _context.next = 15;
+                _context.next = 17;
                 break;
               }
               _context.t0 = callback;
-              _context.next = 11;
+              _context.next = 12;
               return dataFromCache.data;
-            case 11:
+            case 12:
               _context.t1 = _context.sent;
-              (0, _context.t0)(_context.t1);
-              _context.next = 16;
+              _context.t2 = {
+                data: _context.t1
+              };
+              (0, _context.t0)(_context.t2);
+              _context.next = 18;
               break;
-            case 15:
-              callback(dataFromCache.data);
-            case 16:
+            case 17:
+              callback({
+                data: dataFromCache.data
+              });
+            case 18:
               if (!(0, _coreUtils.isSSR)()) {
-                _context.next = 18;
+                _context.next = 20;
                 break;
               }
               return _context.abrupt("return");
-            case 18:
+            case 20:
               if (!((dataFromCache === null || dataFromCache === void 0 ? void 0 : dataFromCache.source) !== 'network')) {
-                _context.next = 27;
+                _context.next = 29;
                 break;
               }
               // Store the current cache version before making the request,
@@ -185,32 +194,44 @@ var NodeDataProvider = exports.NodeDataProvider = /*#__PURE__*/function () {
                   value = _ref4[0];
                 return value;
               }); // Store the promise in the cache to avoid multiple requests for the same data
-              this.cache[dataKey] = {
+              this.cache[_dataKey] = {
                 source: 'network',
                 data: dataPromise
               };
-              _context.next = 24;
+              _context.next = 26;
               return dataPromise;
-            case 24:
+            case 26:
               data = _context.sent;
               // We need to call the callback with the data with result even if the cache version has changed,
               // so all promises that are waiting for the data can resolve.
-              callback(data);
+              callback({
+                data: data
+              });
 
               // If the cache version has changed, we don't want to use the data from the network
               // because it could be stale data.
               if (cacheVersionBeforeRequest === this.cacheVersion) {
                 // Replace promise with the resolved data in the cache
-                this.cache[dataKey] = {
+                this.cache[_dataKey] = {
                   source: 'network',
                   data: data
                 };
               }
-            case 27:
+            case 29:
+              _context.next = 34;
+              break;
+            case 31:
+              _context.prev = 31;
+              _context.t3 = _context["catch"](0);
+              // If an error occurs, we call the callback with the error
+              callback({
+                error: _context.t3 instanceof Error ? _context.t3 : new Error(String(_context.t3))
+              });
+            case 34:
             case "end":
               return _context.stop();
           }
-        }, _callee, this);
+        }, _callee, this, [[0, 31]]);
       }));
       function getDataAsync(_x, _x2) {
         return _getDataAsync.apply(this, arguments);
@@ -239,7 +260,13 @@ var NodeDataProvider = exports.NodeDataProvider = /*#__PURE__*/function () {
       var _this = this;
       return new Promise(function (resolve, reject) {
         try {
-          return _this.getData(node, resolve);
+          _this.getData(node, function (payload) {
+            if (payload.error) {
+              reject(payload.error);
+            } else {
+              resolve(payload.data);
+            }
+          });
         } catch (error) {
           reject(error);
         }

package/dist/cjs/utils/find-nodes-to-prefetch.js

@@ -15,7 +15,9 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
  * @returns An array of objects, each containing a provider and the nodes that are supported by that provider.
  */
 function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
+  // Counter for the total number of visited nodes to limit the traversal.
   var totalVisitedNodesCount = 0;
+  // A map to store the results, with the provider name as the key.
   var resultMap = providers.reduce(function (acc, _ref) {
     var provider = _ref.provider;
     acc[provider.name] = {
@@ -28,6 +30,7 @@ function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
   // It doesn't use `filter` function from `@atlaskit/adf-utils/traverse` because it does not support early stopping.
   // We need to stop traversing when we reach the maximum number of nodes to visit to support large documents.
 
+  // Create a list of providers for which we still need to find nodes.
   var providersToLookup = providers.filter(function (_ref2) {
     var maxNodesToPrefetch = _ref2.maxNodesToPrefetch;
     return maxNodesToPrefetch > 0;
@@ -37,32 +40,46 @@ function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
     return {
       provider: provider,
       maxNodesToPrefetch: maxNodesToPrefetch,
-      foundNodes: 0
+      foundNodes: 0 // Counter for nodes found for each provider.
     };
   });
+
+  // Queue for the breadth-first search (BFS), starting with the root document node.
   var nodesToVisit = [doc];
   var currentIndex = 0;
+  // The loop continues as long as there are nodes to visit, providers to look for,
+  // and the visited nodes limit has not been reached.
   while (currentIndex < nodesToVisit.length && providersToLookup.length > 0 && totalVisitedNodesCount < maxNodesToVisit) {
     totalVisitedNodesCount += 1;
     var currentNode = nodesToVisit[currentIndex];
     currentIndex++;
 
-    // Using reverse loop to avoid issues with array mutation
+    // Using a reverse loop to avoid issues with array mutation (when removing elements).
     for (var i = providersToLookup.length - 1; i >= 0; i--) {
       var providerToFind = providersToLookup[i];
+
+      // Check if the current provider supports this node.
       if (providerToFind.provider.isNodeSupported(currentNode)) {
+        // If provider supports the node, add it to the result map.
         resultMap[providerToFind.provider.name].nodes.push(currentNode);
+        // Increment the count of found nodes for this provider.
         providerToFind.foundNodes += 1;
+
+        // If the provider has found enough nodes, remove it from the lookup list.
         if (providerToFind.foundNodes >= providerToFind.maxNodesToPrefetch) {
           providersToLookup.splice(i, 1);
         }
       }
     }
+
+    // If the current node has children, add them to the queue to be visited.
     if (currentNode.content) {
       nodesToVisit.push.apply(nodesToVisit, (0, _toConsumableArray2.default)(currentNode.content.filter(function (node) {
         return node !== undefined;
       })));
     }
   }
+
+  // Return an array of the found nodes, grouped by provider.
   return Object.values(resultMap);
 }

package/dist/es2019/node-data-provider.js

@@ -24,6 +24,11 @@ import { isSSR } from '@atlaskit/editor-common/core-utils';
  * }
  */
 
+/**
+ * Represents the payload passed to the callback function when data is fetched.
+ * It can either contain an error or the fetched data.
+ */
+
 /**
  * A Node Data Provider is responsible for fetching and caching data associated with specific ProseMirror nodes.
  * It supports a cache-first-then-network strategy, with initial data potentially provided via SSR.
@@ -78,13 +83,10 @@ export class NodeDataProvider {
    */
   setSSRData(ssrData = {}) {
     this.cacheVersion++;
-    this.cache = Object.entries(ssrData).reduce((acc, [key, data]) => {
-      acc[key] = {
-        source: 'ssr',
-        data
-      };
-      return acc;
-    }, {});
+    this.cache = Object.fromEntries(Object.entries(ssrData).map(([key, data]) => [key, {
+      data,
+      source: 'ssr'
+    }]));
   }
 
   /**
@@ -127,7 +129,7 @@ export class NodeDataProvider {
    * ```
    *
    * @param node The node (or its ProseMirror representation) for which to fetch data.
-   * @param callback The function to call when data is available.
+   * @param callback The callback function to call with the fetched data or an error.
    */
   getData(node, callback) {
     // Move implementation to a separate async method
@@ -135,53 +137,66 @@ export class NodeDataProvider {
     void this.getDataAsync(node, callback);
   }
   async getDataAsync(node, callback) {
-    const jsonNode = 'toJSON' in node ? node.toJSON() : node;
-    if (!this.isNodeSupported(jsonNode)) {
-      // eslint-disable-next-line no-console
-      console.error(`The ${this.constructor.name} doesn't support Node ${jsonNode.type}.`);
-      return;
-    }
-    const dataKey = this.nodeDataKey(jsonNode);
-    const dataFromCache = this.cache[dataKey];
-    if (dataFromCache !== undefined) {
-      // If we have the data in the SSR data, we can use it directly
-      if (isPromise(dataFromCache.data)) {
-        callback(await dataFromCache.data);
-      } else {
-        callback(dataFromCache.data);
-      }
-      if (isSSR()) {
-        // If we are in SSR, we don't want to fetch the data again, as it is already available in the SSR data
+    try {
+      const jsonNode = 'toJSON' in node ? node.toJSON() : node;
+      if (!this.isNodeSupported(jsonNode)) {
+        // eslint-disable-next-line no-console
+        console.error(`The ${this.constructor.name} doesn't support Node ${jsonNode.type}.`);
         return;
       }
-    }
-
-    // If no data is available in the cache or the data is from the network,
-    // we need to fetch it from the network.
-    if ((dataFromCache === null || dataFromCache === void 0 ? void 0 : dataFromCache.source) !== 'network') {
-      // Store the current cache version before making the request,
-      // so we can check if the cache has changed while we are waiting for the network response.
-      const cacheVersionBeforeRequest = this.cacheVersion;
-      const dataPromise = this.fetchNodesData([jsonNode]).then(([value]) => value);
-      // Store the promise in the cache to avoid multiple requests for the same data
-      this.cache[dataKey] = {
-        source: 'network',
-        data: dataPromise
-      };
-      const data = await dataPromise;
-      // We need to call the callback with the data with result even if the cache version has changed,
-      // so all promises that are waiting for the data can resolve.
-      callback(data);
+      const dataKey = this.nodeDataKey(jsonNode);
+      const dataFromCache = this.cache[dataKey];
+      if (dataFromCache !== undefined) {
+        // If we have the data in the SSR data, we can use it directly
+        if (isPromise(dataFromCache.data)) {
+          callback({
+            data: await dataFromCache.data
+          });
+        } else {
+          callback({
+            data: dataFromCache.data
+          });
+        }
+        if (isSSR()) {
+          // If we are in SSR, we don't want to fetch the data again, as it is already available in the SSR data
+          return;
+        }
+      }
 
-      // If the cache version has changed, we don't want to use the data from the network
-      // because it could be stale data.
-      if (cacheVersionBeforeRequest === this.cacheVersion) {
-        // Replace promise with the resolved data in the cache
+      // If no data is available in the cache or the data is from the network,
+      // we need to fetch it from the network.
+      if ((dataFromCache === null || dataFromCache === void 0 ? void 0 : dataFromCache.source) !== 'network') {
+        // Store the current cache version before making the request,
+        // so we can check if the cache has changed while we are waiting for the network response.
+        const cacheVersionBeforeRequest = this.cacheVersion;
+        const dataPromise = this.fetchNodesData([jsonNode]).then(([value]) => value);
+        // Store the promise in the cache to avoid multiple requests for the same data
         this.cache[dataKey] = {
           source: 'network',
-          data
+          data: dataPromise
         };
+        const data = await dataPromise;
+        // We need to call the callback with the data with result even if the cache version has changed,
+        // so all promises that are waiting for the data can resolve.
+        callback({
+          data
+        });
+
+        // If the cache version has changed, we don't want to use the data from the network
+        // because it could be stale data.
+        if (cacheVersionBeforeRequest === this.cacheVersion) {
+          // Replace promise with the resolved data in the cache
+          this.cache[dataKey] = {
+            source: 'network',
+            data
+          };
+        }
       }
+    } catch (error) {
+      // If an error occurs, we call the callback with the error
+      callback({
+        error: error instanceof Error ? error : new Error(String(error))
+      });
     }
   }
 
@@ -204,7 +219,13 @@ export class NodeDataProvider {
   getDataAsPromise_DO_NOT_USE_OUTSIDE_MIGRATIONS(node) {
     return new Promise((resolve, reject) => {
       try {
-        return this.getData(node, resolve);
+        this.getData(node, payload => {
+          if (payload.error) {
+            reject(payload.error);
+          } else {
+            resolve(payload.data);
+          }
+        });
       } catch (error) {
         reject(error);
       }

package/dist/es2019/utils/find-nodes-to-prefetch.js

@@ -7,7 +7,9 @@
  * @returns An array of objects, each containing a provider and the nodes that are supported by that provider.
  */
 export function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
+  // Counter for the total number of visited nodes to limit the traversal.
   let totalVisitedNodesCount = 0;
+  // A map to store the results, with the provider name as the key.
   const resultMap = providers.reduce((acc, {
     provider
   }) => {
@@ -21,6 +23,7 @@ export function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
   // It doesn't use `filter` function from `@atlaskit/adf-utils/traverse` because it does not support early stopping.
   // We need to stop traversing when we reach the maximum number of nodes to visit to support large documents.
 
+  // Create a list of providers for which we still need to find nodes.
   const providersToLookup = providers.filter(({
     maxNodesToPrefetch
   }) => maxNodesToPrefetch > 0).map(({
@@ -29,29 +32,43 @@ export function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
   }) => ({
     provider,
     maxNodesToPrefetch,
-    foundNodes: 0
+    foundNodes: 0 // Counter for nodes found for each provider.
   }));
+
+  // Queue for the breadth-first search (BFS), starting with the root document node.
   const nodesToVisit = [doc];
   let currentIndex = 0;
+  // The loop continues as long as there are nodes to visit, providers to look for,
+  // and the visited nodes limit has not been reached.
   while (currentIndex < nodesToVisit.length && providersToLookup.length > 0 && totalVisitedNodesCount < maxNodesToVisit) {
     totalVisitedNodesCount += 1;
     const currentNode = nodesToVisit[currentIndex];
     currentIndex++;
 
-    // Using reverse loop to avoid issues with array mutation
+    // Using a reverse loop to avoid issues with array mutation (when removing elements).
     for (let i = providersToLookup.length - 1; i >= 0; i--) {
       const providerToFind = providersToLookup[i];
+
+      // Check if the current provider supports this node.
       if (providerToFind.provider.isNodeSupported(currentNode)) {
+        // If provider supports the node, add it to the result map.
         resultMap[providerToFind.provider.name].nodes.push(currentNode);
+        // Increment the count of found nodes for this provider.
         providerToFind.foundNodes += 1;
+
+        // If the provider has found enough nodes, remove it from the lookup list.
         if (providerToFind.foundNodes >= providerToFind.maxNodesToPrefetch) {
           providersToLookup.splice(i, 1);
         }
       }
     }
+
+    // If the current node has children, add them to the queue to be visited.
     if (currentNode.content) {
       nodesToVisit.push(...currentNode.content.filter(node => node !== undefined));
     }
   }
+
+  // Return an array of the found nodes, grouped by provider.
   return Object.values(resultMap);
 }

package/dist/esm/node-data-provider.js

@@ -30,6 +30,11 @@ import { isSSR } from '@atlaskit/editor-common/core-utils';
  * }
  */
 
+/**
+ * Represents the payload passed to the callback function when data is fetched.
+ * It can either contain an error or the fetched data.
+ */
+
 /**
  * A Node Data Provider is responsible for fetching and caching data associated with specific ProseMirror nodes.
  * It supports a cache-first-then-network strategy, with initial data potentially provided via SSR.
@@ -62,16 +67,15 @@ export var NodeDataProvider = /*#__PURE__*/function () {
     value: function setSSRData() {
       var ssrData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       this.cacheVersion++;
-      this.cache = Object.entries(ssrData).reduce(function (acc, _ref) {
+      this.cache = Object.fromEntries(Object.entries(ssrData).map(function (_ref) {
         var _ref2 = _slicedToArray(_ref, 2),
           key = _ref2[0],
           data = _ref2[1];
-        acc[key] = {
-          source: 'ssr',
-          data: data
-        };
-        return acc;
-      }, {});
+        return [key, {
+          data: data,
+          source: 'ssr'
+        }];
+      }));
     }
 
     /**
@@ -116,7 +120,7 @@ export var NodeDataProvider = /*#__PURE__*/function () {
      * ```
      *
      * @param node The node (or its ProseMirror representation) for which to fetch data.
-     * @param callback The function to call when data is available.
+     * @param callback The callback function to call with the fetched data or an error.
      */
   }, {
     key: "getData",
@@ -129,48 +133,54 @@ export var NodeDataProvider = /*#__PURE__*/function () {
     key: "getDataAsync",
     value: function () {
       var _getDataAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(node, callback) {
-        var jsonNode, dataKey, dataFromCache, cacheVersionBeforeRequest, dataPromise, data;
+        var jsonNode, _dataKey, dataFromCache, cacheVersionBeforeRequest, dataPromise, data;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
+              _context.prev = 0;
               jsonNode = 'toJSON' in node ? node.toJSON() : node;
               if (this.isNodeSupported(jsonNode)) {
-                _context.next = 4;
+                _context.next = 5;
                 break;
               }
               // eslint-disable-next-line no-console
               console.error("The ".concat(this.constructor.name, " doesn't support Node ").concat(jsonNode.type, "."));
               return _context.abrupt("return");
-            case 4:
-              dataKey = this.nodeDataKey(jsonNode);
-              dataFromCache = this.cache[dataKey];
+            case 5:
+              _dataKey = this.nodeDataKey(jsonNode);
+              dataFromCache = this.cache[_dataKey];
               if (!(dataFromCache !== undefined)) {
-                _context.next = 18;
+                _context.next = 20;
                 break;
               }
               if (!isPromise(dataFromCache.data)) {
-                _context.next = 15;
+                _context.next = 17;
                 break;
               }
               _context.t0 = callback;
-              _context.next = 11;
+              _context.next = 12;
               return dataFromCache.data;
-            case 11:
+            case 12:
               _context.t1 = _context.sent;
-              (0, _context.t0)(_context.t1);
-              _context.next = 16;
+              _context.t2 = {
+                data: _context.t1
+              };
+              (0, _context.t0)(_context.t2);
+              _context.next = 18;
               break;
-            case 15:
-              callback(dataFromCache.data);
-            case 16:
+            case 17:
+              callback({
+                data: dataFromCache.data
+              });
+            case 18:
               if (!isSSR()) {
-                _context.next = 18;
+                _context.next = 20;
                 break;
               }
               return _context.abrupt("return");
-            case 18:
+            case 20:
               if (!((dataFromCache === null || dataFromCache === void 0 ? void 0 : dataFromCache.source) !== 'network')) {
-                _context.next = 27;
+                _context.next = 29;
                 break;
               }
               // Store the current cache version before making the request,
@@ -181,32 +191,44 @@ export var NodeDataProvider = /*#__PURE__*/function () {
                   value = _ref4[0];
                 return value;
               }); // Store the promise in the cache to avoid multiple requests for the same data
-              this.cache[dataKey] = {
+              this.cache[_dataKey] = {
                 source: 'network',
                 data: dataPromise
               };
-              _context.next = 24;
+              _context.next = 26;
               return dataPromise;
-            case 24:
+            case 26:
               data = _context.sent;
               // We need to call the callback with the data with result even if the cache version has changed,
               // so all promises that are waiting for the data can resolve.
-              callback(data);
+              callback({
+                data: data
+              });
 
               // If the cache version has changed, we don't want to use the data from the network
               // because it could be stale data.
               if (cacheVersionBeforeRequest === this.cacheVersion) {
                 // Replace promise with the resolved data in the cache
-                this.cache[dataKey] = {
+                this.cache[_dataKey] = {
                   source: 'network',
                   data: data
                 };
               }
-            case 27:
+            case 29:
+              _context.next = 34;
+              break;
+            case 31:
+              _context.prev = 31;
+              _context.t3 = _context["catch"](0);
+              // If an error occurs, we call the callback with the error
+              callback({
+                error: _context.t3 instanceof Error ? _context.t3 : new Error(String(_context.t3))
+              });
+            case 34:
             case "end":
               return _context.stop();
           }
-        }, _callee, this);
+        }, _callee, this, [[0, 31]]);
       }));
       function getDataAsync(_x, _x2) {
         return _getDataAsync.apply(this, arguments);
@@ -235,7 +257,13 @@ export var NodeDataProvider = /*#__PURE__*/function () {
       var _this = this;
       return new Promise(function (resolve, reject) {
         try {
-          return _this.getData(node, resolve);
+          _this.getData(node, function (payload) {
+            if (payload.error) {
+              reject(payload.error);
+            } else {
+              resolve(payload.data);
+            }
+          });
         } catch (error) {
           reject(error);
         }

package/dist/esm/utils/find-nodes-to-prefetch.js

@@ -8,7 +8,9 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
  * @returns An array of objects, each containing a provider and the nodes that are supported by that provider.
  */
 export function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
+  // Counter for the total number of visited nodes to limit the traversal.
   var totalVisitedNodesCount = 0;
+  // A map to store the results, with the provider name as the key.
   var resultMap = providers.reduce(function (acc, _ref) {
     var provider = _ref.provider;
     acc[provider.name] = {
@@ -21,6 +23,7 @@ export function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
   // It doesn't use `filter` function from `@atlaskit/adf-utils/traverse` because it does not support early stopping.
   // We need to stop traversing when we reach the maximum number of nodes to visit to support large documents.
 
+  // Create a list of providers for which we still need to find nodes.
   var providersToLookup = providers.filter(function (_ref2) {
     var maxNodesToPrefetch = _ref2.maxNodesToPrefetch;
     return maxNodesToPrefetch > 0;
@@ -30,32 +33,46 @@ export function findNodesToPrefetch(doc, providers, maxNodesToVisit) {
     return {
       provider: provider,
       maxNodesToPrefetch: maxNodesToPrefetch,
-      foundNodes: 0
+      foundNodes: 0 // Counter for nodes found for each provider.
     };
   });
+
+  // Queue for the breadth-first search (BFS), starting with the root document node.
   var nodesToVisit = [doc];
   var currentIndex = 0;
+  // The loop continues as long as there are nodes to visit, providers to look for,
+  // and the visited nodes limit has not been reached.
   while (currentIndex < nodesToVisit.length && providersToLookup.length > 0 && totalVisitedNodesCount < maxNodesToVisit) {
     totalVisitedNodesCount += 1;
     var currentNode = nodesToVisit[currentIndex];
     currentIndex++;
 
-    // Using reverse loop to avoid issues with array mutation
+    // Using a reverse loop to avoid issues with array mutation (when removing elements).
     for (var i = providersToLookup.length - 1; i >= 0; i--) {
       var providerToFind = providersToLookup[i];
+
+      // Check if the current provider supports this node.
       if (providerToFind.provider.isNodeSupported(currentNode)) {
+        // If provider supports the node, add it to the result map.
         resultMap[providerToFind.provider.name].nodes.push(currentNode);
+        // Increment the count of found nodes for this provider.
         providerToFind.foundNodes += 1;
+
+        // If the provider has found enough nodes, remove it from the lookup list.
         if (providerToFind.foundNodes >= providerToFind.maxNodesToPrefetch) {
           providersToLookup.splice(i, 1);
         }
       }
     }
+
+    // If the current node has children, add them to the queue to be visited.
     if (currentNode.content) {
       nodesToVisit.push.apply(nodesToVisit, _toConsumableArray(currentNode.content.filter(function (node) {
         return node !== undefined;
       })));
     }
   }
+
+  // Return an array of the found nodes, grouped by provider.
   return Object.values(resultMap);
 }

package/dist/types/node-data-provider.d.ts

@@ -13,6 +13,19 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 type SSRData<Data> = {
     [dataKey: string]: Data;
 };
+/**
+ * Represents the payload passed to the callback function when data is fetched.
+ * It can either contain an error or the fetched data.
+ */
+type CallbackPayload<Data> = {
+    /** An error that occurred while fetching data. */
+    error: Error;
+    data?: undefined;
+} | {
+    /** Fetched data for the node. */
+    data: Data;
+    error?: undefined;
+};
 /**
  * A Node Data Provider is responsible for fetching and caching data associated with specific ProseMirror nodes.
  * It supports a cache-first-then-network strategy, with initial data potentially provided via SSR.
@@ -100,9 +113,9 @@ export declare abstract class NodeDataProvider<Node extends JSONNode, Data> {
      * ```
      *
      * @param node The node (or its ProseMirror representation) for which to fetch data.
-     * @param callback The function to call when data is available.
+     * @param callback The callback function to call with the fetched data or an error.
      */
-    getData(node: Node | PMNode, callback: (data: Data) => void): void;
+    getData(node: Node | PMNode, callback: (payload: CallbackPayload<Data>) => void): void;
     private getDataAsync;
     /**
      * Fetches data for a given node and returns it as a Promise.

package/dist/types-ts4.5/node-data-provider.d.ts

@@ -13,6 +13,19 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 type SSRData<Data> = {
     [dataKey: string]: Data;
 };
+/**
+ * Represents the payload passed to the callback function when data is fetched.
+ * It can either contain an error or the fetched data.
+ */
+type CallbackPayload<Data> = {
+    /** An error that occurred while fetching data. */
+    error: Error;
+    data?: undefined;
+} | {
+    /** Fetched data for the node. */
+    data: Data;
+    error?: undefined;
+};
 /**
  * A Node Data Provider is responsible for fetching and caching data associated with specific ProseMirror nodes.
  * It supports a cache-first-then-network strategy, with initial data potentially provided via SSR.
@@ -100,9 +113,9 @@ export declare abstract class NodeDataProvider<Node extends JSONNode, Data> {
      * ```
      *
      * @param node The node (or its ProseMirror representation) for which to fetch data.
-     * @param callback The function to call when data is available.
+     * @param callback The callback function to call with the fetched data or an error.
      */
-    getData(node: Node | PMNode, callback: (data: Data) => void): void;
+    getData(node: Node | PMNode, callback: (payload: CallbackPayload<Data>) => void): void;
     private getDataAsync;
     /**
      * Fetches data for a given node and returns it as a Promise.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/node-data-provider",
-	"version": "4.3.0",
+	"version": "4.4.0",
 	"description": "Node data provider for @atlaskit/editor-core plugins and @atlaskit/renderer",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -22,7 +22,7 @@
 		".": "./src/index.ts"
 	},
 	"dependencies": {
-		"@atlaskit/adf-schema": "^49.0.6",
+		"@atlaskit/adf-schema": "^50.0.1",
 		"@atlaskit/adf-utils": "^19.20.0",
 		"@atlaskit/editor-json-transformer": "^8.24.0",
 		"@atlaskit/editor-prosemirror": "7.0.0",