@atlaskit/node-data-provider 4.3.0 → 4.5.0

package/dist/es2019/utils/prefetch-node-data-providers-data.js

@@ -13,14 +13,28 @@ import { findNodesToPrefetch } from './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: '😊' }
+ *     }
+ *   }
  * }
+ * ```
  */
 
 /**
@@ -43,7 +57,7 @@ import { findNodesToPrefetch } from './find-nodes-to-prefetch';
  *   },
  * ];
  *
- * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ * const data = await prefetchNodeDataProvidersData({
  *   providers,
  *   doc,
  *   timeout: 1_000,
@@ -53,7 +67,7 @@ import { findNodesToPrefetch } from './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.
  */
 export async function prefetchNodeDataProvidersData({
   providers,
@@ -91,21 +105,29 @@ export async function prefetchNodeDataProvidersData({
     provider,
     timeout
   }) => {
+    const start = performance.now();
+    function getDurationFromStart() {
+      return Math.min(performance.now() - start, timeout);
+    }
     try {
-      const timeoutPromise = new Promise(resolve => {
+      const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => {
-          resolve([]);
+          reject();
         }, timeout);
       });
       const data = await Promise.race([provider.fetchNodesData(nodes), timeoutPromise]);
       return {
         provider,
+        success: true,
+        duration: getDurationFromStart(),
         nodes,
         data
       };
     } catch {
       return {
         provider,
+        success: false,
+        duration: getDurationFromStart(),
         nodes,
         data: []
       };
@@ -114,15 +136,22 @@ export async function prefetchNodeDataProvidersData({
   const results = await Promise.all(promises);
   return results.reduce((acc, {
     provider,
+    success,
+    duration,
     nodes,
     data
   }) => {
-    acc[provider.name] = data.reduce((providerSsrData, nodeData, nodeIndex) => {
+    const ssrData = data.reduce((providerSsrData, nodeData, nodeIndex) => {
       const node = nodes[nodeIndex];
       const nodeDataKey = provider.nodeDataKey(node);
       providerSsrData[nodeDataKey] = nodeData;
       return providerSsrData;
     }, {});
+    acc[provider.name] = {
+      data: ssrData,
+      success,
+      duration
+    };
     return acc;
   }, {});
 }

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/esm/utils/prefetch-node-data-providers-data.js

@@ -15,14 +15,28 @@ import { findNodesToPrefetch } from './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: '😊' }
+ *     }
+ *   }
  * }
+ * ```
  */
 
 /**
@@ -45,7 +59,7 @@ import { findNodesToPrefetch } from './find-nodes-to-prefetch';
  *   },
  * ];
  *
- * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ * const data = await prefetchNodeDataProvidersData({
  *   providers,
  *   doc,
  *   timeout: 1_000,
@@ -55,7 +69,7 @@ import { findNodesToPrefetch } from './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.
  */
 export function prefetchNodeDataProvidersData(_x) {
   return _prefetchNodeDataProvidersData.apply(this, arguments);
@@ -97,39 +111,47 @@ function _prefetchNodeDataProvidersData() {
           });
           promises = nodesWithProviders.map( /*#__PURE__*/function () {
             var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref5) {
-              var nodes, provider, timeout, timeoutPromise, data;
+              var nodes, provider, timeout, start, getDurationFromStart, timeoutPromise, data;
               return _regeneratorRuntime.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);
@@ -141,14 +163,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/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/utils/prefetch-node-data-providers-data.d.ts

@@ -15,17 +15,35 @@ type SsrData = {
 };
 /**
  * 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: '😊' }
+ *     }
+ *   }
  * }
+ * ```
  */
 type NodeDataProvidersSsrData = {
-    [providerName: string]: SsrData;
+    [providerName: string]: {
+        success: boolean;
+        duration: number;
+        data: SsrData;
+    };
 };
 interface Props {
     /**
@@ -91,7 +109,7 @@ interface Props {
  *   },
  * ];
  *
- * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ * const data = await prefetchNodeDataProvidersData({
  *   providers,
  *   doc,
  *   timeout: 1_000,
@@ -101,7 +119,7 @@ interface Props {
  *
  * @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.
  */
 export declare function prefetchNodeDataProvidersData({ providers, doc, timeout, maxNodesToVisit, }: Props): Promise<NodeDataProvidersSsrData>;
 export {};

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/dist/types-ts4.5/utils/prefetch-node-data-providers-data.d.ts

@@ -15,17 +15,35 @@ type SsrData = {
 };
 /**
  * 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: '😊' }
+ *     }
+ *   }
  * }
+ * ```
  */
 type NodeDataProvidersSsrData = {
-    [providerName: string]: SsrData;
+    [providerName: string]: {
+        success: boolean;
+        duration: number;
+        data: SsrData;
+    };
 };
 interface Props {
     /**
@@ -91,7 +109,7 @@ interface Props {
  *   },
  * ];
  *
- * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ * const data = await prefetchNodeDataProvidersData({
  *   providers,
  *   doc,
  *   timeout: 1_000,
@@ -101,7 +119,7 @@ interface Props {
  *
  * @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.
  */
 export declare function prefetchNodeDataProvidersData({ providers, doc, timeout, maxNodesToVisit, }: Props): Promise<NodeDataProvidersSsrData>;
 export {};