@atlaskit/node-data-provider 4.3.0 → 4.5.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @atlaskit/node-data-provider
 
+## 4.5.0
+
+### Minor Changes
+
+- [#193382](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/193382)
+  [`5c827a7e9ac42`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/5c827a7e9ac42) -
+  [https://product-fabric.atlassian.net/browse/ED-28627](ED-28627) - add `duration` and `success` to
+  `prefetchNodeDataProvidersData` result
+
+## 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/cjs/utils/prefetch-node-data-providers-data.js

@@ -20,14 +20,28 @@ var _findNodesToPrefetch = require("./find-nodes-to-prefetch");
  */
 /**
  * Represents the aggregated SSR data for all node data providers.
- * It's a map where each key is a provider's name and the value is the {@link SsrData} for that provider.
- * This structure is used to hydrate the client-side caches.
+ * Each key is a provider's name, and the value contains the fetch status, duration,
+ * and a map of node data keys to their prefetched data.
  *
  * @example
+ * ```
  * {
- *   'mentionProvider': { 'mention-1': { id: '1', name: 'John Doe' } },
- *   'emojiProvider': { 'emoji-123': { shortName: ':smile:', representation: '😊' } }
+ *   mentionProvider: {
+ *     success: true,
+ *     duration: 220,
+ *     data: {
+ *       'mention-1': { id: '1', name: 'John Doe' }
+ *     }
+ *   },
+ *   emojiProvider: {
+ *     success: true,
+ *     duration: 110,
+ *     data: {
+ *       'emoji-123': { shortName: ':smile:', representation: '😊' }
+ *     }
+ *   }
  * }
+ * ```
  */
 /**
  * Fetches data for nodes in the document that are supported by the given providers.
@@ -49,7 +63,7 @@ var _findNodesToPrefetch = require("./find-nodes-to-prefetch");
  *   },
  * ];
  *
- * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ * const data = await prefetchNodeDataProvidersData({
  *   providers,
  *   doc,
  *   timeout: 1_000,
@@ -59,7 +73,7 @@ var _findNodesToPrefetch = require("./find-nodes-to-prefetch");
  *
  * @param props The properties for prefetching node data.
  * @returns Record of provider names to their respective SSR data,
- *          where each SSR data is a record of node data keys to the fetched data.
+ *          success status, and duration of the fetch operation.
  */
 function prefetchNodeDataProvidersData(_x) {
   return _prefetchNodeDataProvidersData.apply(this, arguments);
@@ -101,39 +115,47 @@ function _prefetchNodeDataProvidersData() {
           });
           promises = nodesWithProviders.map( /*#__PURE__*/function () {
             var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref5) {
-              var nodes, provider, timeout, timeoutPromise, data;
+              var nodes, provider, timeout, start, getDurationFromStart, timeoutPromise, data;
               return _regenerator.default.wrap(function _callee$(_context) {
                 while (1) switch (_context.prev = _context.next) {
                   case 0:
+                    getDurationFromStart = function _getDurationFromStart() {
+                      return Math.min(performance.now() - start, timeout);
+                    };
                     nodes = _ref5.nodes, provider = _ref5.provider, timeout = _ref5.timeout;
-                    _context.prev = 1;
-                    timeoutPromise = new Promise(function (resolve) {
+                    start = performance.now();
+                    _context.prev = 3;
+                    timeoutPromise = new Promise(function (_, reject) {
                       setTimeout(function () {
-                        resolve([]);
+                        reject();
                       }, timeout);
                     });
-                    _context.next = 5;
+                    _context.next = 7;
                     return Promise.race([provider.fetchNodesData(nodes), timeoutPromise]);
-                  case 5:
+                  case 7:
                     data = _context.sent;
                     return _context.abrupt("return", {
                       provider: provider,
+                      success: true,
+                      duration: getDurationFromStart(),
                       nodes: nodes,
                       data: data
                     });
-                  case 9:
-                    _context.prev = 9;
-                    _context.t0 = _context["catch"](1);
+                  case 11:
+                    _context.prev = 11;
+                    _context.t0 = _context["catch"](3);
                     return _context.abrupt("return", {
                       provider: provider,
+                      success: false,
+                      duration: getDurationFromStart(),
                       nodes: nodes,
                       data: []
                     });
-                  case 12:
+                  case 14:
                   case "end":
                     return _context.stop();
                 }
-              }, _callee, null, [[1, 9]]);
+              }, _callee, null, [[3, 11]]);
             }));
             return function (_x2) {
               return _ref6.apply(this, arguments);
@@ -145,14 +167,21 @@ function _prefetchNodeDataProvidersData() {
           results = _context2.sent;
           return _context2.abrupt("return", results.reduce(function (acc, _ref7) {
             var provider = _ref7.provider,
+              success = _ref7.success,
+              duration = _ref7.duration,
               nodes = _ref7.nodes,
               data = _ref7.data;
-            acc[provider.name] = data.reduce(function (providerSsrData, nodeData, nodeIndex) {
+            var ssrData = data.reduce(function (providerSsrData, nodeData, nodeIndex) {
               var node = nodes[nodeIndex];
               var nodeDataKey = provider.nodeDataKey(node);
               providerSsrData[nodeDataKey] = nodeData;
               return providerSsrData;
             }, {});
+            acc[provider.name] = {
+              data: ssrData,
+              success: success,
+              duration: duration
+            };
             return acc;
           }, {}));
         case 9:

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);
 }