@atlaskit/node-data-provider 2.0.0

package/dist/cjs/index.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeDataProvider = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// re exported to avoid type issues
+// this type is only used in jsdoc comments in this file.
+/**
+ * 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});
+ * ```
+ */
+var NodeDataProvider = exports.NodeDataProvider = /*#__PURE__*/function () {
+  /**
+   * This takes a node and returns a key that can be used to cache the result of the resolve function.
+   */
+
+  /**
+   * 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.
+   */
+
+  /**
+   * The adf node name this provider is responsible for.
+   */
+
+  function NodeDataProvider(_ref) {
+    var _ref$existingCache = _ref.existingCache,
+      existingCache = _ref$existingCache === void 0 ? {} : _ref$existingCache,
+      nodeName = _ref.nodeName,
+      nodeToKey = _ref.nodeToKey,
+      resolve = _ref.resolve;
+    (0, _classCallCheck2.default)(this, NodeDataProvider);
+    /**
+     * This is added to ease building types
+     */
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (0, _defineProperty2.default)(this, "__node", {});
+    (0, _defineProperty2.default)(this, "pending", {});
+    this.__cache = existingCache;
+    this.nodeName = nodeName;
+    this.nodeToKey = nodeToKey;
+    this.resolve = 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}
+   *
+   */
+  (0, _createClass2.default)(NodeDataProvider, [{
+    key: "updateCache",
+    value: function updateCache(cache, options) {
+      switch (options.strategy) {
+        case 'merge-override':
+          this.__cache = _objectSpread(_objectSpread({}, this.__cache), cache);
+          return;
+        case 'replace':
+          this.__cache = cache;
+          return;
+      }
+    }
+
+    /**
+     * This is the cache for the provider.
+     */
+  }, {
+    key: "cache",
+    get: function get() {
+      return this.__cache;
+    }
+  }, {
+    key: "get",
+    value: function get(node, _) {
+      var _this = this;
+      var key = this.nodeToKey(node);
+      var cached = this.cache[key];
+      if (cached) {
+        return cached;
+      }
+
+      // Get could be called from a variety of sources;
+      // - a Node Data Provider
+      // - a cache build
+      // - something else
+      //
+      // We want to avoid triggering multiple resolves for the same node -- so we keep track of pending requests
+      // and share them across any overlapping gets.
+      //
+      // When a get is cancelled -- we only want to cancel the shared resolve if all signals are aborted
+      // so we keep track of all signals that are not aborted.
+
+      var originalSignal = (_ === null || _ === void 0 ? void 0 : _.signal) || new AbortController().signal;
+      if (!this.pending[key]) {
+        var abortController = new AbortController();
+        this.pending[key] = {
+          resolving: new Promise( /*#__PURE__*/function () {
+            var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(res, rej) {
+              var result;
+              return _regenerator.default.wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.prev = 0;
+                    _context.next = 3;
+                    return _this.resolve(node, {
+                      signal: abortController.signal
+                    }).catch(function (res) {
+                      return res(undefined);
+                    });
+                  case 3:
+                    result = _context.sent;
+                    res(result);
+                    _context.next = 10;
+                    break;
+                  case 7:
+                    _context.prev = 7;
+                    _context.t0 = _context["catch"](0);
+                    res(undefined);
+                  case 10:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee, null, [[0, 7]]);
+            }));
+            return function (_x, _x2) {
+              return _ref2.apply(this, arguments);
+            };
+          }()),
+          abortController: abortController,
+          activeSignals: [originalSignal]
+        };
+      }
+      var handleAbort = function handleAbort() {
+        _this.pending[key].activeSignals = _this.pending[key].activeSignals.filter(function (activeSignal) {
+          return activeSignal !== originalSignal;
+        });
+        if (_this.pending[key].activeSignals.length === 0) {
+          // abort the resolution if all signals are aborted
+          _this.pending[key].abortController.abort();
+        }
+      };
+
+      // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+      originalSignal === null || originalSignal === void 0 || originalSignal.addEventListener('abort', handleAbort);
+      this.pending[key].resolving.then(function (resolvedValue) {
+        if (resolvedValue) {
+          _this.cache[key] = resolvedValue;
+        }
+        // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+        originalSignal === null || originalSignal === void 0 || originalSignal.removeEventListener('abort', handleAbort);
+        return resolvedValue;
+      });
+      return this.pending[key].resolving;
+    }
+  }]);
+  return NodeDataProvider;
+}(); // The purpose of this type is to ensure that either a DocNode or a PMNode is passed in
+// to the provider.
+// It is not opinionated about which nodes are used, so `any` is used here to allow
+// compatibility with both DocNodes and PMNodes.

package/dist/cjs/internal-types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/plugin-hooks.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNodeDataProviderGet = useNodeDataProviderGet;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+/**
+ *
+ *
+ * This hook is intended to simplify accessing data via the one tick providers.
+ *
+ * ```ts
+ * const value = useNodeDataProviderGet(emojiProvider, emojiNode);
+ *
+ * if (value.state === 'loading') {
+ *   return <Loading />;
+ * }
+ * if (value.state === 'failed') {
+ *  return <Fallback />;
+ * }
+ * return <Emoji properties=(value.result) />
+ * ```
+ */
+function useNodeDataProviderGet(options) {
+  var getResult = (0, _react.useMemo)(function () {
+    return options.provider.get(options.node);
+  }, [options.provider, options.node]);
+  var _useState = (0, _react.useState)(getResult !== undefined && !isPromise(getResult) ? getResult : undefined),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    resolved = _useState2[0],
+    setResolved = _useState2[1];
+  (0, _react.useEffect)(function () {
+    if (!isPromise(getResult)) {
+      return;
+    }
+    var cancelled = false;
+    (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var _resolved;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return getResult;
+          case 3:
+            _resolved = _context.sent;
+            if (!cancelled) {
+              if (_resolved === undefined) {
+                setResolved('error');
+              } else {
+                setResolved(_resolved);
+              }
+            }
+            _context.next = 10;
+            break;
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](0);
+            setResolved('error');
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 7]]);
+    }))();
+    return function () {
+      cancelled = true;
+    };
+  }, [getResult]);
+  if (resolved === undefined) {
+    return {
+      state: 'loading',
+      result: undefined
+    };
+  }
+  if (resolved === 'error') {
+    return {
+      state: 'failed',
+      result: undefined
+    };
+  }
+  return {
+    state: 'resolved',
+    result: resolved
+  };
+}
+function isPromise(obj) {
+  return !!obj && ((0, _typeof2.default)(obj) === 'object' || typeof obj === 'function') &&
+  // @ts-ignore
+  typeof obj.then === 'function';
+}

package/dist/cjs/providers/emoji.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEmojiNodeDataProvider = createEmojiNodeDataProvider;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _index = require("../index");
+function createEmojiNodeDataProvider(_ref) {
+  var emojiProvider = _ref.emojiProvider,
+    existingCache = _ref.existingCache;
+  var emojiNodeDataProvider = new _index.NodeDataProvider({
+    existingCache: existingCache,
+    nodeName: 'emoji',
+    nodeToKey: function nodeToKey(node) {
+      var key = "".concat(node.attrs.id, "-").concat(node.attrs.shortName, "-").concat(node.attrs.text);
+      return key;
+    },
+    resolve: function resolve(node, _resolveOptions) {
+      return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var emojiDescriptionWithVariations;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return emojiProvider;
+            case 2:
+              _context.next = 4;
+              return _context.sent.fetchByEmojiId({
+                id: node.attrs.id,
+                shortName: node.attrs.shortName,
+                fallback: node.attrs.text
+              }, true);
+            case 4:
+              emojiDescriptionWithVariations = _context.sent;
+              if (emojiDescriptionWithVariations) {
+                _context.next = 7;
+                break;
+              }
+              throw new Error('Could not resolve emoji');
+            case 7:
+              return _context.abrupt("return", emojiDescriptionWithVariations);
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }))();
+    }
+  });
+  return emojiNodeDataProvider;
+}

package/dist/es2019/cache.js

@@ -0,0 +1,96 @@
+import { traverse } from '@atlaskit/adf-utils/traverse';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * Builds {@link NodeDataProvider}s caches for a document.
+ *
+ * It will traverse the document and call the resolve method for each node.
+ * When all promises are resolved, NodeDataProviders will have their caches populated.
+ *
+ * The providers will then be ready for use with an Editor.
+ *
+ * To limit the time spent building the cache, a signal can be provided to abort the request.
+ *
+ * ## Usage
+ *
+ * @example
+ * ```ts
+ * buildCaches({
+ *  adf: doc,
+ *  nodeDataProviders: { emoji: emojiNodeDataProvider, ... },
+ *  signal: AbortSignal.timeout(5000),
+ * });
+ * ```
+ *
+ * ### Using caches
+ *
+ * To make use of a cache in another provider (ie. for a cache created on the server), you can retrieve the cache
+ * from the provider and pass it to the new provider.
+ *
+ * @example
+ * ```tsx
+ * // SSR env
+ * const ssrProvidersCaches = await buildCaches({adf, nodeDataProviders: { emoji }})
+ *
+ * // Client env (providersCaches is the cache from the server)
+ * <ContentNodeDataProviders ... existingProvidersCache={ssrProvidersCaches} />
+ * ```
+ *
+ * *Note:* On the client - buildCache is not expected to be used directly.
+ *
+ * @see {@link ContentNodeDataProviders} for expected client usage.
+ */
+export async function buildCaches({
+  adf,
+  nodeDataProviders,
+  signal = new AbortController().signal,
+  existingProvidersCache
+}) {
+  let visitors = {};
+  let promises = [];
+  for (const _nodeDataProvider of Object.values(nodeDataProviders)) {
+    // widen type to avoid typescript errors with the specific node data provider types
+    const nodeDataProvider = _nodeDataProvider;
+    if (existingProvidersCache && existingProvidersCache[nodeDataProvider.nodeName]) {
+      nodeDataProvider.updateCache(existingProvidersCache[nodeDataProvider.nodeName], {
+        strategy: 'merge-override'
+      });
+    }
+    visitors[nodeDataProvider.nodeName] = node => {
+      const result = nodeDataProvider.get(node, {
+        signal
+      });
+      if (!isPromise(result)) {
+        nodeDataProvider.cache[nodeDataProvider.nodeToKey(node)] = result;
+        return;
+      }
+      promises.push(result);
+      result.then(resolvedValue => {
+        const signalAborted = signal ? signal.aborted : false;
+        if (!signalAborted && resolvedValue !== undefined) {
+          nodeDataProvider.cache[nodeDataProvider.nodeToKey(node)] = resolvedValue;
+        }
+      });
+      return undefined;
+    };
+  }
+  if (adf) {
+    traverse(adf, visitors);
+    await Promise.all(promises);
+  } else {
+    await Promise.resolve();
+  }
+  const caches = {};
+  for (const nodeDataProvider of Object.values(nodeDataProviders)) {
+    caches[nodeDataProvider.nodeName] = nodeDataProvider.cache;
+  }
+  return caches;
+}
+function isPromise(obj) {
+  return !!obj && (typeof obj === 'object' || typeof obj === 'function') &&
+  // @ts-ignore
+  typeof obj.then === 'function';
+}

package/dist/es2019/consumption/_global-ndp-caches.js

@@ -0,0 +1,13 @@
+import React from 'react';
+let GlobalNdpCachesContext = /*#__PURE__*/React.createContext({});
+export function useGlobalNdpCachesContext() {
+  const globalNdpCachesContextValue = React.useContext(GlobalNdpCachesContext);
+  return globalNdpCachesContextValue;
+}
+
+// The ndp caches currently use module scope to store the caches. This is not ideal, and a global provider
+// will avoid the need for this.
+// This function is used to reset the global ndp caches context in tests.
+export function _resetGlobalNdpCachesContext() {
+  GlobalNdpCachesContext = /*#__PURE__*/React.createContext({});
+}

package/dist/es2019/consumption/_internal-context.js

@@ -0,0 +1,71 @@
+import React from 'react';
+import { buildCaches } from '../cache';
+import { useGlobalNdpCachesContext } from './_global-ndp-caches';
+import { LRUCache } from './_lru-cache';
+
+/**
+ * The settings for the data providers lru cache,
+ * increasing the value will increase the number of data providers that can be stored in the cache.
+ */
+const lruCacheSettings = {
+  page: 5,
+  default: 1
+};
+
+/**
+ * Sets up nodeview data providers for a content node.
+ *
+ * This will return the cached node data providers if they exist, otherwise it will call the provided getNodeDataProviders function.
+ *
+ * Note: Calling this has side effects where caches for the nodeview data providers will continue to be built
+ * in the background after this resolves to a set of nodeview data providers that can be used.
+ */
+export function useContentNodeDataProvidersSetup(content,
+/**
+ * Note: changes to this object will not be reflected in the cache.
+ */
+setupOptions) {
+  const _globalNdpCachesContextValue = useGlobalNdpCachesContext();
+  // Create a cache for the content type if it doesn't exist
+  // While this will not result in any existing context consumers getting the updated value.
+  // It will ensure that the cache is available for future consumers.
+  if (_globalNdpCachesContextValue[content.contentType] === undefined) {
+    var _lruCacheSettings$con;
+    _globalNdpCachesContextValue[content.contentType] = new LRUCache((_lruCacheSettings$con = lruCacheSettings[content.contentType]) !== null && _lruCacheSettings$con !== void 0 ? _lruCacheSettings$con : lruCacheSettings.default);
+  }
+  const contentTypeNdpCaches = _globalNdpCachesContextValue[content.contentType];
+
+  // The node data providers should only be rebuilt if the content changes
+  // to avoid unnecessary rebuilding of the cache.
+  // useRef is used over useMemo as use memo is not a guarantee that the value will be reused
+  // - in development it can be called twice
+  // - react have made clear that in future versions useMemo may add features that throw away the cache, and [recommend refs](https://react.dev/reference/react/useMemo#caveats) for this use case.
+  const currentContentKey = `${content.contentType}-${content.contentId}`;
+  const contentKeyRef = React.useRef();
+  const nodeDataProvidersRef = React.useRef();
+  if (contentKeyRef.current !== currentContentKey) {
+    contentKeyRef.current = currentContentKey;
+    const cachedContentNdps = contentTypeNdpCaches === null || contentTypeNdpCaches === void 0 ? void 0 : contentTypeNdpCaches.get(content.contentId);
+    let nodeDataProviders = cachedContentNdps || setupOptions.getNodeDataProviders();
+
+    /**
+     * Note: while this will remove old NodeDataProviders from the cache -- these are passed directly to consumers,
+     * so removing from the cache will not result in actively used NodeDataProviders being deleted in some way.
+     *
+     */
+    contentTypeNdpCaches.set(content.contentId, nodeDataProviders);
+    buildCaches({
+      adf: setupOptions.adfToUpdateWith,
+      nodeDataProviders: nodeDataProviders,
+      existingProvidersCache: setupOptions.existingProvidersCache
+    }).then(warmedNodeDataProvidersCache => {
+      var _setupOptions$onCache;
+      (_setupOptions$onCache = setupOptions.onCacheWarmed) === null || _setupOptions$onCache === void 0 ? void 0 : _setupOptions$onCache.call(setupOptions, {
+        warmedNodeDataProvidersCache,
+        nodeDataProviders
+      });
+    });
+    nodeDataProvidersRef.current = nodeDataProviders;
+  }
+  return nodeDataProvidersRef.current;
+}

package/dist/es2019/consumption/_lru-cache.js

@@ -0,0 +1,28 @@
+export class LRUCache {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.cache = new Map();
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return undefined;
+    }
+
+    // Move the used key to the end to mark it as most recently used
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    // Check if the key already exists and delete it to update its position
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      // Remove the first (least recently used) cache item if we're at capacity
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(key, value);
+  }
+}

package/dist/es2019/consumption/content.js

@@ -0,0 +1,46 @@
+import React from 'react';
+import { _resetGlobalNdpCachesContext } from './_global-ndp-caches';
+import { useContentNodeDataProvidersSetup } from './_internal-context';
+const ContentNodeDataProvidersContext = /*#__PURE__*/React.createContext(undefined);
+
+/**
+ *
+ * @example
+ * ```tsx
+ * <ContentNodeDataProviders
+ * 	contentType="page" contentId="9001"
+ * 	adf={doc}
+ * 	placeholder={<Spinner />}
+ * 	existingProvidersCache={ssrProvidersCache}
+ * 	getNodeDataProviders={getPageNodeDataProviders}
+ * 	onCacheWarmed={trackCacheWarmed}
+ * >
+ * 	 <Editor />
+ * </ContentNodeDataProviders>
+ * ```
+ */
+export function ContentNodeDataProviders(props) {
+  const contentNodeDataProviders = useContentNodeDataProvidersSetup({
+    contentType: props.contentType,
+    contentId: props.contentId
+  }, {
+    adfToUpdateWith: props.adf,
+    existingProvidersCache: props.existingProvidersCache,
+    getNodeDataProviders: props.getNodeDataProviders,
+    onCacheWarmed: props.onCacheWarmed
+  });
+  return /*#__PURE__*/React.createElement(ContentNodeDataProvidersContext.Provider, {
+    value: contentNodeDataProviders
+  }, props.children);
+}
+export function useContentNodeDataProviders() {
+  const contentNodeDataProvidersContext = React.useContext(ContentNodeDataProvidersContext);
+  return contentNodeDataProvidersContext;
+}
+export {
+/**
+ * Exported for testing purposes only.
+ *
+ * This API will change.
+ */
+_resetGlobalNdpCachesContext as __testOnly_resetGlobalNdpCachesContext };

package/dist/es2019/get-providers/confluence-page.js

@@ -0,0 +1,10 @@
+import { createEmojiNodeDataProvider } from '../providers/emoji';
+export function getConfluencePageProviders({
+  emojiProvider
+}) {
+  return {
+    emoji: createEmojiNodeDataProvider({
+      emojiProvider
+    })
+  };
+}