@atlaskit/node-data-provider 4.1.2 → 4.3.0

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

@@ -0,0 +1,161 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { findNodesToPrefetch } from './find-nodes-to-prefetch';
+
+/**
+ * Represents the SSR data for a single provider.
+ * It's a map where each key is a unique node data key and the value is the prefetched data for that node.
+ *
+ * @example
+ * {
+ *   'node-id-1': { value: 'some data' },
+ *   'node-id-2': { value: 'other data' }
+ * }
+ */
+
+/**
+ * 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.
+ *
+ * @example
+ * {
+ *   'mentionProvider': { 'mention-1': { id: '1', name: 'John Doe' } },
+ *   'emojiProvider': { 'emoji-123': { shortName: ':smile:', representation: '😊' } }
+ * }
+ */
+
+/**
+ * Fetches data for nodes in the document that are supported by the given providers.
+ * This function will traverse the document and call the `fetchData` method for each node that is supported by the providers.
+ *
+ * @example
+ * ```
+ * const doc = JSON.parse('{"type": "doc", "content": [...] }');
+ * const providers = [
+ *   {
+ *     provider: new EditorCardProvider(),
+ *  	  maxNodesToPrefetch: 10,
+ *  	  timeout: 500,
+ *  	},
+ *   {
+ *     provider: new EditorMentionsProvider(),
+ *     maxNodesToPrefetch: 50,
+ *  	  timeout: 500,
+ *   },
+ * ];
+ *
+ * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ *   providers,
+ *   doc,
+ *   timeout: 1_000,
+ *   maxNodesToVisit: 2_000
+ * });
+ * ```
+ *
+ * @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.
+ */
+export function prefetchNodeDataProvidersData(_x) {
+  return _prefetchNodeDataProvidersData.apply(this, arguments);
+}
+function _prefetchNodeDataProvidersData() {
+  _prefetchNodeDataProvidersData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref) {
+    var providers, doc, timeout, _ref$maxNodesToVisit, maxNodesToVisit, providersWithDefaults, providerTimeouts, nodesWithProviders, promises, results;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          providers = _ref.providers, doc = _ref.doc, timeout = _ref.timeout, _ref$maxNodesToVisit = _ref.maxNodesToVisit, maxNodesToVisit = _ref$maxNodesToVisit === void 0 ? Infinity : _ref$maxNodesToVisit;
+          providersWithDefaults = providers.map(function (_ref2) {
+            var provider = _ref2.provider,
+              _ref2$maxNodesToPrefe = _ref2.maxNodesToPrefetch,
+              maxNodesToPrefetch = _ref2$maxNodesToPrefe === void 0 ? Infinity : _ref2$maxNodesToPrefe,
+              _ref2$timeout = _ref2.timeout,
+              providerTimeout = _ref2$timeout === void 0 ? Infinity : _ref2$timeout;
+            return {
+              provider: provider,
+              maxNodesToPrefetch: maxNodesToPrefetch,
+              // Use the minimum of the global timeout and the provider-specific timeout
+              timeout: Math.min(providerTimeout, timeout)
+            };
+          });
+          providerTimeouts = providersWithDefaults.reduce(function (acc, _ref3) {
+            var provider = _ref3.provider,
+              timeout = _ref3.timeout;
+            acc[provider.name] = timeout;
+            return acc;
+          }, {});
+          nodesWithProviders = findNodesToPrefetch(doc, providersWithDefaults, maxNodesToVisit).map(function (_ref4) {
+            var provider = _ref4.provider,
+              nodes = _ref4.nodes;
+            return {
+              provider: provider,
+              nodes: nodes,
+              timeout: providerTimeouts[provider.name]
+            };
+          });
+          promises = nodesWithProviders.map( /*#__PURE__*/function () {
+            var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref5) {
+              var nodes, provider, timeout, timeoutPromise, data;
+              return _regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    nodes = _ref5.nodes, provider = _ref5.provider, timeout = _ref5.timeout;
+                    _context.prev = 1;
+                    timeoutPromise = new Promise(function (resolve) {
+                      setTimeout(function () {
+                        resolve([]);
+                      }, timeout);
+                    });
+                    _context.next = 5;
+                    return Promise.race([provider.fetchNodesData(nodes), timeoutPromise]);
+                  case 5:
+                    data = _context.sent;
+                    return _context.abrupt("return", {
+                      provider: provider,
+                      nodes: nodes,
+                      data: data
+                    });
+                  case 9:
+                    _context.prev = 9;
+                    _context.t0 = _context["catch"](1);
+                    return _context.abrupt("return", {
+                      provider: provider,
+                      nodes: nodes,
+                      data: []
+                    });
+                  case 12:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee, null, [[1, 9]]);
+            }));
+            return function (_x2) {
+              return _ref6.apply(this, arguments);
+            };
+          }());
+          _context2.next = 7;
+          return Promise.all(promises);
+        case 7:
+          results = _context2.sent;
+          return _context2.abrupt("return", results.reduce(function (acc, _ref7) {
+            var provider = _ref7.provider,
+              nodes = _ref7.nodes,
+              data = _ref7.data;
+            acc[provider.name] = data.reduce(function (providerSsrData, nodeData, nodeIndex) {
+              var node = nodes[nodeIndex];
+              var nodeDataKey = provider.nodeDataKey(node);
+              providerSsrData[nodeDataKey] = nodeData;
+              return providerSsrData;
+            }, {});
+            return acc;
+          }, {}));
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _prefetchNodeDataProvidersData.apply(this, arguments);
+}

package/dist/types/index.d.ts

@@ -1,134 +1,2 @@
-/**
- * This is the base class for creating a node data provider for an editor plugin.
- *
- * ## Usage
- *
- * ### Create a provider
- *
- * @example
- * ```ts
- * class EmojiNodeDataProvider extends NodeDataProvider<
- *  { attrs: EmojiAttributes },
- * { resolvedData: string }
- * > {
- *   constructor({ existingCache }?: { existingCache: Record<string, { resolvedData: string }> }) {
- *     super({ existingCache, nodeName: 'emoji' });
- *   }
- *   nodeToKey(node: { attrs: EmojiAttributes }): string {
- *     return `${node.attrs.shortName}-${node.attrs.text}-${node.attrs.id}`;
- *   }
- *   resolve(node: { attrs: EmojiAttributes }, _?: { signal: AbortSignal }) {
- *     return Promise.resolve({ resolvedData: 'resolved' });
- *   }
- * }
- * ```
- *
- * ### Use the provider
- *
- * @example
- * ```ts
- * const emojiNodeDataProvider = new EmojiNodeDataProvider();
- * ```
- *
- * ### Caching
- *
- * @see {@link buildCaches} for more information on building caches.
- *
- * #### Load an existing provider with a cache
- *
- * @example
- * ```
- * await buildCaches({
- *  adf: docFromSomewhere,
- *  nodeDataProviders: [emojiNodeDataProvider],
- *  signal: AbortSignal.timeout(5000),
- * });
- * emojiNodeDataProvider // { 'key': 'value' }
- * ```
- *
- * ### Load an new provider with an existing cache
- *
- * @example
- * ```
- * const provider1 = new ExampleNodeDataProvider();
- * await buildCaches({adf, nodeDataProviders: [provider1]})
- * provider1.cache // { 'key': 'value' }
- *
- * const provider2 = new ExampleNodeDataProvider({existingCache: provider1.cache});
- * ```
- */
-export declare class NodeDataProvider<INode extends ReceivableNode, Result extends unknown> {
-    /**
-     * This is added to ease building types
-     */
-    __node: INode;
-    private __cache;
-    /**
-     * This takes a node and returns a key that can be used to cache the result of the resolve function.
-     */
-    nodeToKey: (node: INode) => string;
-    /**
-     * This returns the information required to render a node.
-     *
-     * If unresolvable, this method will throw an error.
-     *
-     * If signal is aborted, this method will return undefined.
-     */
-    resolve: (node: INode, _?: {
-        signal?: AbortSignal;
-    }) => Promise<Result | undefined>;
-    /**
-     * The adf node name this provider is responsible for.
-     */
-    nodeName: string;
-    constructor({ existingCache, nodeName, nodeToKey, resolve, }: {
-        /**
-         * A cache to load the provider with.
-         *
-         * @see {@link buildCaches} for more information on building caches.
-         */
-        existingCache?: Record<string, Result>;
-        /**
-         * The adf node name this provider is responsible for.
-         *
-         * It is used for;
-         * - determining if the traverser should use this provider to resolve a node when building caches
-         * - identifying the node when submitting analytics events via the helper react hooks
-         */
-        nodeName: string;
-        nodeToKey: typeof NodeDataProvider.prototype.nodeToKey;
-        resolve: typeof NodeDataProvider.prototype.resolve;
-    });
-    /**
-     * Updates the providers cache.
-     *
-     * Useful in scenarios such as SSR where the cache is built on the server and then passed to the client.
-     *
-     * Avoids the need to provide the cache to the constructor (to allow decoupling creation of node data providers from cache building),
-     * and allow for caching to be managed at a group level across multiple providers.
-     *
-     * This is not expected to be used by consumers, for internal consumption examples;
-     * @see {@link buildCaches}
-     *
-     */
-    updateCache(cache: Record<string, Result>, options: {
-        strategy: 'merge-override' | 'replace';
-    }): void;
-    /**
-     * This is the cache for the provider.
-     */
-    get cache(): Record<string, Result>;
-    private pending;
-    get(node: INode, _?: {
-        signal: AbortSignal;
-    }): Promise<Result | undefined> | Result;
-}
-export type ReceivableNode = {
-    [key: string]: any;
-    attrs: {
-        [key: string]: any;
-    };
-};
-export type ResolveOptions = {
-    signal: AbortSignal;
-};
+export { NodeDataProvider } from './node-data-provider';
+export { prefetchNodeDataProvidersData } from './utils/prefetch-node-data-providers-data';

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

@@ -0,0 +1,125 @@
+import type { JSONNode } from '@atlaskit/editor-json-transformer';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Represents the SSR data for a single provider.
+ * It's a map where each key is a unique node data key and the value is the prefetched data for that node.
+ *
+ * @example
+ * {
+ *   'node-id-1': { value: 'some data' },
+ *   'node-id-2': { value: 'other data' }
+ * }
+ */
+type SSRData<Data> = {
+    [dataKey: string]: 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.
+ *
+ * @template Node The specific type of JSONNode this provider supports.
+ * @template Data The type of data this provider fetches and manages.
+ */
+export declare abstract class NodeDataProvider<Node extends JSONNode, Data> {
+    private cacheVersion;
+    private cache;
+    /**
+     * A unique name for the provider. Used for identification in SSR.
+     */
+    abstract readonly name: string;
+    /**
+     * A type guard to check if a given JSONNode is supported by this provider.
+     * Used to ensure that the provider can handle the node type before attempting to fetch data.
+     *
+     * @param node The node to check.
+     * @returns `true` if the node is of the type supported by this provider, otherwise `false`.
+     */
+    abstract isNodeSupported(node: JSONNode): node is Node;
+    /**
+     * Generates a unique key for a given node to be used for caching.
+     *
+     * @param node The node for which to generate a data key.
+     * @returns A unique string key for the node's data.
+     */
+    abstract nodeDataKey(node: Node): string;
+    /**
+     * Fetches data for a batch of nodes from the network or another asynchronous source.
+     *
+     * @param nodes An array of nodes for which to fetch data.
+     * @returns A promise that resolves to an array of data corresponding to the input nodes.
+     */
+    abstract fetchNodesData(nodes: Node[]): Promise<Data[]>;
+    protected constructor();
+    /**
+     * Sets the SSR data for the provider.
+     * This pre-populates the cache with data rendered on the server, preventing redundant network requests on the client.
+     * Calling this method will invalidate the existing cache.
+     *
+     * @example
+     * ```
+     * const ssrData = window.__SSR_NODE_DATA__ || {};
+     * nodeDataProvider.setSSRData(ssrData);
+     * ```
+     *
+     * @param ssrData A map of node data keys to their corresponding data.
+     */
+    setSSRData(ssrData?: SSRData<Data>): void;
+    /**
+     * Clears all cached data.
+     * This increments the internal cache version, invalidating any pending network requests.
+     *
+     * @example
+     * ```
+     * function useMyNodeDataProvider(contentId: string) {
+     *  const nodeDataProvider = new MyNodeDataProvider();
+     *
+     *  // Reset the cache when the contentId changes (e.g., when the user navigates to a different page).
+     *  useEffect(() => {
+     *    nodeDataProvider.resetCache();
+     *  }, [contentId]);
+     *
+     *  return nodeDataProvider;
+     * }
+     * ```
+     */
+    resetCache(): void;
+    /**
+     * Fetches data for a given node using a cache-first-then-network strategy.
+     *
+     * The provided callback may be called multiple times:
+     * 1. Immediately with data from the SSR cache, if available.
+     * 2. Asynchronously with data fetched from the network.
+     *
+     * @example
+     * ```
+     * const nodeDataProvider = new MyNodeDataProvider();
+     *
+     * nodeDataProvider.getData(node, (data) => {
+     * 	console.log('Node data:', data);
+     * });
+     * ```
+     *
+     * @param node The node (or its ProseMirror representation) for which to fetch data.
+     * @param callback The function to call when data is available.
+     */
+    getData(node: Node | PMNode, callback: (data: Data) => void): void;
+    private getDataAsync;
+    /**
+     * Fetches data for a given node and returns it as a Promise.
+     * This is a convenience wrapper around the `data` method for use with async/await.
+     *
+     * Note: This promise resolves with the *first* available data, which could be from the SSR cache or the network.
+     * It may not provide the most up-to-date data if a network fetch is in progress.
+     *
+     * Note: This method is only for migration purposes. Use {@link getData} in new code instead.
+     *
+     * @private
+     * @deprecated Don't use this method, use {@link getData} method instead.
+     *             This method is only for migration purposes.
+     *
+     * @param node The node (or its ProseMirror representation) for which to fetch data.
+     * @returns A promise that resolves with the node's data.
+     */
+    getDataAsPromise_DO_NOT_USE_OUTSIDE_MIGRATIONS(node: Node | PMNode): Promise<Data>;
+}
+export {};

package/dist/types/utils/find-nodes-to-prefetch.d.ts

@@ -0,0 +1,21 @@
+import type { JSONDocNode, JSONNode } from '@atlaskit/editor-json-transformer';
+import type { NodeDataProvider } from '../node-data-provider';
+interface ProviderWithNodes {
+    /** The provider that supports the nodes. */
+    provider: NodeDataProvider<JSONNode, unknown>;
+    /** The nodes that are supported by the provider. */
+    nodes: JSONNode[];
+}
+/**
+ * Finds nodes in the document that are supported by the given providers, up to a maximum number of nodes.
+ *
+ * @param doc The document to search for nodes.
+ * @param providers An array of providers with their maximum nodes to prefetch.
+ * @param maxNodesToVisit The maximum number of nodes to visit in the document.
+ * @returns An array of objects, each containing a provider and the nodes that are supported by that provider.
+ */
+export declare function findNodesToPrefetch(doc: JSONDocNode, providers: {
+    provider: NodeDataProvider<JSONNode, unknown>;
+    maxNodesToPrefetch: number;
+}[], maxNodesToVisit: number): ProviderWithNodes[];
+export {};

package/dist/types/utils/prefetch-node-data-providers-data.d.ts

@@ -0,0 +1,107 @@
+import type { JSONDocNode, JSONNode } from '@atlaskit/editor-json-transformer';
+import type { NodeDataProvider } from '../node-data-provider';
+/**
+ * Represents the SSR data for a single provider.
+ * It's a map where each key is a unique node data key and the value is the prefetched data for that node.
+ *
+ * @example
+ * {
+ *   'node-id-1': { value: 'some data' },
+ *   'node-id-2': { value: 'other data' }
+ * }
+ */
+type SsrData = {
+    [dataKey: string]: unknown;
+};
+/**
+ * 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.
+ *
+ * @example
+ * {
+ *   'mentionProvider': { 'mention-1': { id: '1', name: 'John Doe' } },
+ *   'emojiProvider': { 'emoji-123': { shortName: ':smile:', representation: '😊' } }
+ * }
+ */
+type NodeDataProvidersSsrData = {
+    [providerName: string]: SsrData;
+};
+interface Props {
+    /**
+     * The document for which to prefetch data.
+     */
+    doc: JSONDocNode;
+    /**
+     * A global timeout in milliseconds for all fetch requests.
+     *
+     * Each provider will use the minimum of this value and its own specific timeout.
+     */
+    timeout: number;
+    /**
+     * The maximum number of nodes to visit when searching for nodes to prefetch.
+     * This is a performance safeguard for very large documents.
+     *
+     * @default If not specified, the entire document will be traversed.
+     */
+    maxNodesToVisit?: number;
+    /**
+     * A list of node data providers to use for prefetching, along with their
+     * individual configurations.
+     */
+    providers: {
+        /**
+         * The provider instance to use for prefetching.
+         */
+        provider: NodeDataProvider<JSONNode, unknown>;
+        /**
+         * The maximum number of nodes to prefetch for this specific provider.
+         * This helps prevent performance issues with documents containing many
+         * nodes of the same type.
+         *
+         * @default If not specified, all nodes supported by the provider will be prefetched.
+         */
+        maxNodesToPrefetch?: number;
+        /**
+         * The timeout in milliseconds for the fetch request for this specific provider.
+         * If the request takes longer than this, it will be aborted and return no data.
+         *
+         * @default If not specified, the global timeout will be used.
+         */
+        timeout?: number;
+    }[];
+}
+/**
+ * Fetches data for nodes in the document that are supported by the given providers.
+ * This function will traverse the document and call the `fetchData` method for each node that is supported by the providers.
+ *
+ * @example
+ * ```
+ * const doc = JSON.parse('{"type": "doc", "content": [...] }');
+ * const providers = [
+ *   {
+ *     provider: new EditorCardProvider(),
+ *  	  maxNodesToPrefetch: 10,
+ *  	  timeout: 500,
+ *  	},
+ *   {
+ *     provider: new EditorMentionsProvider(),
+ *     maxNodesToPrefetch: 50,
+ *  	  timeout: 500,
+ *   },
+ * ];
+ *
+ * window['__SSR_EDITOR_NODE_DATA_PROVIDERS_DATA__'] = await prefetchNodeDataProvidersData({
+ *   providers,
+ *   doc,
+ *   timeout: 1_000,
+ *   maxNodesToVisit: 2_000
+ * });
+ * ```
+ *
+ * @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.
+ */
+export declare function prefetchNodeDataProvidersData({ providers, doc, timeout, maxNodesToVisit, }: Props): Promise<NodeDataProvidersSsrData>;
+export {};

package/dist/types-ts4.5/index.d.ts

@@ -1,134 +1,2 @@
-/**
- * This is the base class for creating a node data provider for an editor plugin.
- *
- * ## Usage
- *
- * ### Create a provider
- *
- * @example
- * ```ts
- * class EmojiNodeDataProvider extends NodeDataProvider<
- *  { attrs: EmojiAttributes },
- * { resolvedData: string }
- * > {
- *   constructor({ existingCache }?: { existingCache: Record<string, { resolvedData: string }> }) {
- *     super({ existingCache, nodeName: 'emoji' });
- *   }
- *   nodeToKey(node: { attrs: EmojiAttributes }): string {
- *     return `${node.attrs.shortName}-${node.attrs.text}-${node.attrs.id}`;
- *   }
- *   resolve(node: { attrs: EmojiAttributes }, _?: { signal: AbortSignal }) {
- *     return Promise.resolve({ resolvedData: 'resolved' });
- *   }
- * }
- * ```
- *
- * ### Use the provider
- *
- * @example
- * ```ts
- * const emojiNodeDataProvider = new EmojiNodeDataProvider();
- * ```
- *
- * ### Caching
- *
- * @see {@link buildCaches} for more information on building caches.
- *
- * #### Load an existing provider with a cache
- *
- * @example
- * ```
- * await buildCaches({
- *  adf: docFromSomewhere,
- *  nodeDataProviders: [emojiNodeDataProvider],
- *  signal: AbortSignal.timeout(5000),
- * });
- * emojiNodeDataProvider // { 'key': 'value' }
- * ```
- *
- * ### Load an new provider with an existing cache
- *
- * @example
- * ```
- * const provider1 = new ExampleNodeDataProvider();
- * await buildCaches({adf, nodeDataProviders: [provider1]})
- * provider1.cache // { 'key': 'value' }
- *
- * const provider2 = new ExampleNodeDataProvider({existingCache: provider1.cache});
- * ```
- */
-export declare class NodeDataProvider<INode extends ReceivableNode, Result extends unknown> {
-    /**
-     * This is added to ease building types
-     */
-    __node: INode;
-    private __cache;
-    /**
-     * This takes a node and returns a key that can be used to cache the result of the resolve function.
-     */
-    nodeToKey: (node: INode) => string;
-    /**
-     * This returns the information required to render a node.
-     *
-     * If unresolvable, this method will throw an error.
-     *
-     * If signal is aborted, this method will return undefined.
-     */
-    resolve: (node: INode, _?: {
-        signal?: AbortSignal;
-    }) => Promise<Result | undefined>;
-    /**
-     * The adf node name this provider is responsible for.
-     */
-    nodeName: string;
-    constructor({ existingCache, nodeName, nodeToKey, resolve, }: {
-        /**
-         * A cache to load the provider with.
-         *
-         * @see {@link buildCaches} for more information on building caches.
-         */
-        existingCache?: Record<string, Result>;
-        /**
-         * The adf node name this provider is responsible for.
-         *
-         * It is used for;
-         * - determining if the traverser should use this provider to resolve a node when building caches
-         * - identifying the node when submitting analytics events via the helper react hooks
-         */
-        nodeName: string;
-        nodeToKey: typeof NodeDataProvider.prototype.nodeToKey;
-        resolve: typeof NodeDataProvider.prototype.resolve;
-    });
-    /**
-     * Updates the providers cache.
-     *
-     * Useful in scenarios such as SSR where the cache is built on the server and then passed to the client.
-     *
-     * Avoids the need to provide the cache to the constructor (to allow decoupling creation of node data providers from cache building),
-     * and allow for caching to be managed at a group level across multiple providers.
-     *
-     * This is not expected to be used by consumers, for internal consumption examples;
-     * @see {@link buildCaches}
-     *
-     */
-    updateCache(cache: Record<string, Result>, options: {
-        strategy: 'merge-override' | 'replace';
-    }): void;
-    /**
-     * This is the cache for the provider.
-     */
-    get cache(): Record<string, Result>;
-    private pending;
-    get(node: INode, _?: {
-        signal: AbortSignal;
-    }): Promise<Result | undefined> | Result;
-}
-export type ReceivableNode = {
-    [key: string]: any;
-    attrs: {
-        [key: string]: any;
-    };
-};
-export type ResolveOptions = {
-    signal: AbortSignal;
-};
+export { NodeDataProvider } from './node-data-provider';
+export { prefetchNodeDataProvidersData } from './utils/prefetch-node-data-providers-data';