@atlaskit/node-data-provider 2.0.0

package/.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+	rules: {
+		'@typescript-eslint/no-unused-vars': [
+			'error',
+			{
+				args: 'none',
+				vars: 'local',
+				varsIgnorePattern: '^_',
+				ignoreRestSiblings: true,
+			},
+		],
+		'no-unused-vars': 'off',
+	},
+};

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# @atlaskit/node-data-provider
+
+## 2.0.0
+
+### Major Changes
+
+- [#130776](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/130776)
+  [`78ef8af3a4eb6`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/78ef8af3a4eb6) -
+  ED-23237 rename to node data provider
+
+### Minor Changes
+
+- [#130350](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/130350)
+  [`ec22c30b952b8`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/ec22c30b952b8) -
+  [ED-23237] Implement logic to avoid overlapping resolves for the same node, and introduce
+  consumption apis.
+
+## 1.2.0
+
+### Minor Changes
+
+- [#127511](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/127511)
+  [`af3041afea66f`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/af3041afea66f) -
+  ED-23237 iniital nodeview data provider functionality

package/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions and limitations under the
+License.

package/README.md

@@ -0,0 +1,48 @@
+# Editor Node Data Provider
+
+Node Data Provider for use with @atlaskit/editor-core plugins.
+
+**Note:** This component is designed for internal Atlassian development. External contributors will
+be able to use this component but will not be able to submit issues.
+
+## Install
+
+---
+
+- **Install** - _yarn add @atlaskit/node-data-provider_
+- **npm** -
+  [@atlaskit/node-data-provider](https://www.npmjs.com/package/@atlaskit/node-data-provider)
+- **Source** -
+  [Bitbucket](https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/editor/node-data-provider)
+- **Bundle** - [unpkg.com](https://unpkg.com/@atlaskit/node-data-provider/dist/)
+
+## Usage
+
+---
+
+**Internal use only**
+
+@atlaskit/node-data-provider is intended for internal use by the @atlaskit/editor-core and as a
+plugin dependency of the Editor within your product.
+
+Direct use of this component is not supported.
+
+Please see
+[Atlaskit - Node data provider](https://atlaskit.atlassian.com/packages/editor/node-data-provider)
+for documentation and examples for this package.
+
+## Support
+
+---
+
+For internal Atlassian, visit the slack channel
+[#help-editor](https://atlassian.slack.com/archives/CFG3PSQ9E) for support or visit
+[go/editor-help](https://go/editor-help) to submit a bug.
+
+## License
+
+---
+
+Please see
+[Atlassian Frontend - License](https://developer.atlassian.com/cloud/framework/atlassian-frontend/#license)
+for more licensing information.

package/cache/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlaskit/node-data-provider/cache",
+  "main": "../dist/cjs/cache.js",
+  "module": "../dist/esm/cache.js",
+  "module:es2019": "../dist/es2019/cache.js",
+  "sideEffects": false,
+  "types": "../dist/types/cache.d.ts",
+  "typesVersions": {
+    ">=4.5 <5.4": {
+      "*": [
+        "../dist/types-ts4.5/cache.d.ts"
+      ]
+    }
+  }
+}

package/content/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlaskit/node-data-provider/content",
+  "main": "../dist/cjs/consumption/content.js",
+  "module": "../dist/esm/consumption/content.js",
+  "module:es2019": "../dist/es2019/consumption/content.js",
+  "sideEffects": false,
+  "types": "../dist/types/consumption/content.d.ts",
+  "typesVersions": {
+    ">=4.5 <5.4": {
+      "*": [
+        "../dist/types-ts4.5/consumption/content.d.ts"
+      ]
+    }
+  }
+}

package/dist/cjs/cache.js

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCaches = buildCaches;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _traverse = require("@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.
+ */
+function buildCaches(_x) {
+  return _buildCaches.apply(this, arguments);
+}
+function _buildCaches() {
+  _buildCaches = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref) {
+    var adf, nodeDataProviders, _ref$signal, signal, existingProvidersCache, visitors, promises, _loop, _i, _Object$values, caches, _i2, _Object$values2, nodeDataProvider;
+    return _regenerator.default.wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          adf = _ref.adf, nodeDataProviders = _ref.nodeDataProviders, _ref$signal = _ref.signal, signal = _ref$signal === void 0 ? new AbortController().signal : _ref$signal, existingProvidersCache = _ref.existingProvidersCache;
+          visitors = {};
+          promises = [];
+          _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
+            var _nodeDataProvider, nodeDataProvider;
+            return _regenerator.default.wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _nodeDataProvider = _Object$values[_i];
+                  // widen type to avoid typescript errors with the specific node data provider types
+                  nodeDataProvider = _nodeDataProvider;
+                  if (existingProvidersCache && existingProvidersCache[nodeDataProvider.nodeName]) {
+                    nodeDataProvider.updateCache(existingProvidersCache[nodeDataProvider.nodeName], {
+                      strategy: 'merge-override'
+                    });
+                  }
+                  visitors[nodeDataProvider.nodeName] = function (node) {
+                    var result = nodeDataProvider.get(node, {
+                      signal: signal
+                    });
+                    if (!isPromise(result)) {
+                      nodeDataProvider.cache[nodeDataProvider.nodeToKey(node)] = result;
+                      return;
+                    }
+                    promises.push(result);
+                    result.then(function (resolvedValue) {
+                      var signalAborted = signal ? signal.aborted : false;
+                      if (!signalAborted && resolvedValue !== undefined) {
+                        nodeDataProvider.cache[nodeDataProvider.nodeToKey(node)] = resolvedValue;
+                      }
+                    });
+                    return undefined;
+                  };
+                case 4:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop);
+          });
+          _i = 0, _Object$values = Object.values(nodeDataProviders);
+        case 5:
+          if (!(_i < _Object$values.length)) {
+            _context2.next = 10;
+            break;
+          }
+          return _context2.delegateYield(_loop(), "t0", 7);
+        case 7:
+          _i++;
+          _context2.next = 5;
+          break;
+        case 10:
+          if (!adf) {
+            _context2.next = 16;
+            break;
+          }
+          (0, _traverse.traverse)(adf, visitors);
+          _context2.next = 14;
+          return Promise.all(promises);
+        case 14:
+          _context2.next = 18;
+          break;
+        case 16:
+          _context2.next = 18;
+          return Promise.resolve();
+        case 18:
+          caches = {};
+          for (_i2 = 0, _Object$values2 = Object.values(nodeDataProviders); _i2 < _Object$values2.length; _i2++) {
+            nodeDataProvider = _Object$values2[_i2];
+            caches[nodeDataProvider.nodeName] = nodeDataProvider.cache;
+          }
+          return _context2.abrupt("return", caches);
+        case 21:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee);
+  }));
+  return _buildCaches.apply(this, arguments);
+}
+function isPromise(obj) {
+  return !!obj && ((0, _typeof2.default)(obj) === 'object' || typeof obj === 'function') &&
+  // @ts-ignore
+  typeof obj.then === 'function';
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._resetGlobalNdpCachesContext = _resetGlobalNdpCachesContext;
+exports.useGlobalNdpCachesContext = useGlobalNdpCachesContext;
+var _react = _interopRequireDefault(require("react"));
+var GlobalNdpCachesContext = /*#__PURE__*/_react.default.createContext({});
+function useGlobalNdpCachesContext() {
+  var globalNdpCachesContextValue = _react.default.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.
+function _resetGlobalNdpCachesContext() {
+  GlobalNdpCachesContext = /*#__PURE__*/_react.default.createContext({});
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContentNodeDataProvidersSetup = useContentNodeDataProvidersSetup;
+var _react = _interopRequireDefault(require("react"));
+var _cache = require("../cache");
+var _globalNdpCaches = require("./_global-ndp-caches");
+var _lruCache = require("./_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.
+ */
+var 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.
+ */
+function useContentNodeDataProvidersSetup(content,
+/**
+ * Note: changes to this object will not be reflected in the cache.
+ */
+setupOptions) {
+  var _globalNdpCachesContextValue = (0, _globalNdpCaches.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.LRUCache((_lruCacheSettings$con = lruCacheSettings[content.contentType]) !== null && _lruCacheSettings$con !== void 0 ? _lruCacheSettings$con : lruCacheSettings.default);
+  }
+  var 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.
+  var currentContentKey = "".concat(content.contentType, "-").concat(content.contentId);
+  var contentKeyRef = _react.default.useRef();
+  var nodeDataProvidersRef = _react.default.useRef();
+  if (contentKeyRef.current !== currentContentKey) {
+    contentKeyRef.current = currentContentKey;
+    var cachedContentNdps = contentTypeNdpCaches === null || contentTypeNdpCaches === void 0 ? void 0 : contentTypeNdpCaches.get(content.contentId);
+    var 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);
+    (0, _cache.buildCaches)({
+      adf: setupOptions.adfToUpdateWith,
+      nodeDataProviders: nodeDataProviders,
+      existingProvidersCache: setupOptions.existingProvidersCache
+    }).then(function (warmedNodeDataProvidersCache) {
+      var _setupOptions$onCache;
+      (_setupOptions$onCache = setupOptions.onCacheWarmed) === null || _setupOptions$onCache === void 0 || _setupOptions$onCache.call(setupOptions, {
+        warmedNodeDataProvidersCache: warmedNodeDataProvidersCache,
+        nodeDataProviders: nodeDataProviders
+      });
+    });
+    nodeDataProvidersRef.current = nodeDataProviders;
+  }
+  return nodeDataProvidersRef.current;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LRUCache = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var LRUCache = exports.LRUCache = /*#__PURE__*/function () {
+  function LRUCache(capacity) {
+    (0, _classCallCheck2.default)(this, LRUCache);
+    this.capacity = capacity;
+    this.cache = new Map();
+  }
+  (0, _createClass2.default)(LRUCache, [{
+    key: "get",
+    value: function get(key) {
+      if (!this.cache.has(key)) {
+        return undefined;
+      }
+
+      // Move the used key to the end to mark it as most recently used
+      var value = this.cache.get(key);
+      this.cache.delete(key);
+      this.cache.set(key, value);
+      return value;
+    }
+  }, {
+    key: "set",
+    value: function 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
+        var firstKey = this.cache.keys().next().value;
+        this.cache.delete(firstKey);
+      }
+      this.cache.set(key, value);
+    }
+  }]);
+  return LRUCache;
+}();

package/dist/cjs/consumption/content.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContentNodeDataProviders = ContentNodeDataProviders;
+Object.defineProperty(exports, "__testOnly_resetGlobalNdpCachesContext", {
+  enumerable: true,
+  get: function get() {
+    return _globalNdpCaches._resetGlobalNdpCachesContext;
+  }
+});
+exports.useContentNodeDataProviders = useContentNodeDataProviders;
+var _react = _interopRequireDefault(require("react"));
+var _globalNdpCaches = require("./_global-ndp-caches");
+var _internalContext = require("./_internal-context");
+var ContentNodeDataProvidersContext = /*#__PURE__*/_react.default.createContext(undefined);
+
+/**
+ *
+ * @example
+ * ```tsx
+ * <ContentNodeDataProviders
+ * 	contentType="page" contentId="9001"
+ * 	adf={doc}
+ * 	placeholder={<Spinner />}
+ * 	existingProvidersCache={ssrProvidersCache}
+ * 	getNodeDataProviders={getPageNodeDataProviders}
+ * 	onCacheWarmed={trackCacheWarmed}
+ * >
+ * 	 <Editor />
+ * </ContentNodeDataProviders>
+ * ```
+ */
+function ContentNodeDataProviders(props) {
+  var contentNodeDataProviders = (0, _internalContext.useContentNodeDataProvidersSetup)({
+    contentType: props.contentType,
+    contentId: props.contentId
+  }, {
+    adfToUpdateWith: props.adf,
+    existingProvidersCache: props.existingProvidersCache,
+    getNodeDataProviders: props.getNodeDataProviders,
+    onCacheWarmed: props.onCacheWarmed
+  });
+  return /*#__PURE__*/_react.default.createElement(ContentNodeDataProvidersContext.Provider, {
+    value: contentNodeDataProviders
+  }, props.children);
+}
+function useContentNodeDataProviders() {
+  var contentNodeDataProvidersContext = _react.default.useContext(ContentNodeDataProvidersContext);
+  return contentNodeDataProvidersContext;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfluencePageProviders = getConfluencePageProviders;
+var _emoji = require("../providers/emoji");
+function getConfluencePageProviders(_ref) {
+  var emojiProvider = _ref.emojiProvider;
+  return {
+    emoji: (0, _emoji.createEmojiNodeDataProvider)({
+      emojiProvider: emojiProvider
+    })
+  };
+}