@atlaskit/editor-plugin-synced-block 0.1.0

package/dist/es2019/ui/extensions/synced-block/utils/content-property.js

@@ -0,0 +1,108 @@
+import { getCloudId } from '../constants';
+import { getConfluencePageAri } from './ari';
+
+// Uncomment for proxy in Atlaskit, which will route to hello.atlassian.net
+// const BASE_URL = 'https://localhost:9876';
+const BASE_URL = `/gateway/api/ex/confluence/${getCloudId()}`;
+const API_BASE_URL = `${BASE_URL}/wiki/api/v2`;
+const COMMON_HEADERS = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json'
+};
+const getContentPropertiesUrl = ({
+  pageId,
+  contentPropertyId
+}) => {
+  const url = `${API_BASE_URL}/pages/${pageId}/properties`;
+  if (contentPropertyId) {
+    return `${url}/${contentPropertyId}`;
+  }
+  return url;
+};
+const getGraphQLPropertiesUrl = () => {
+  return `/cgraphql/api/graphql`;
+};
+export const createContentProperty = async ({
+  pageId,
+  key,
+  value
+}) => {
+  const url = getContentPropertiesUrl({
+    pageId
+  });
+  const body = JSON.stringify({
+    key,
+    value
+  });
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: COMMON_HEADERS,
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create content property: ${response.statusText}`);
+  }
+  const contentProperty = await response.json();
+  return contentProperty;
+};
+export const getContentProperty = async ({
+  pageId,
+  contentPropertyId,
+  signal
+}) => {
+  const url = getContentPropertiesUrl({
+    pageId,
+    contentPropertyId
+  });
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: COMMON_HEADERS,
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to get content property: ${response.statusText}`);
+  }
+  const contentProperty = await response.json();
+  return contentProperty;
+};
+const getQuery = (documentARI, key, value) => {
+  return `mutation {
+	  confluence {
+	    updateValuePageProperty(input: {
+	      pageId: "${documentARI}",
+	      key: "${key}",
+	      value: "${value}",
+	      useSameVersion: true
+	    }) {
+	      pageProperty {
+	        key,
+	        value
+	      }
+	    }
+	  }
+	}`;
+};
+export const updateContentProperty = async ({
+  pageId,
+  key,
+  value
+}) => {
+  const url = getGraphQLPropertiesUrl();
+  const documentARI = getConfluencePageAri(pageId);
+
+  // eslint-disable-next-line require-unicode-regexp
+  const query = getQuery(documentARI, key, value.replace(/"/g, '\\"'));
+  const bodyData = {
+    query
+  };
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify(bodyData)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to update content property: ${response.statusText}`);
+  }
+  const contentProperty = await response.json();
+  return contentProperty;
+};

package/dist/es2019/ui/extensions/synced-block/utils/synced-block.js

@@ -0,0 +1,57 @@
+export const SYNCED_BLOCK_EXTENSION_TYPE = 'com.atlassian.platform.extensions';
+export const SYNCED_BLOCK_EXTENSION_KEY = 'synced-block';
+export const SYNCED_BLOCK_SOURCE_NODE = 'source';
+export const SYNCED_BLOCK_SOURCE_KEY = `${SYNCED_BLOCK_EXTENSION_KEY}:${SYNCED_BLOCK_SOURCE_NODE}`;
+export const SYNCED_BLOCK_REFERENCE_NODE = 'reference';
+export const SYNCED_BLOCK_REFERENCE_KEY = `${SYNCED_BLOCK_EXTENSION_KEY}:${SYNCED_BLOCK_REFERENCE_NODE}`;
+export const isSyncedBlockAttributes = attributes => {
+  return !!attributes && typeof attributes === 'object' && 'extensionKey' in attributes && (attributes.extensionKey === SYNCED_BLOCK_SOURCE_KEY || attributes.extensionKey === SYNCED_BLOCK_REFERENCE_KEY);
+};
+export const getDefaultSyncedBlockContent = () => {
+  const attributes = {
+    extensionType: SYNCED_BLOCK_EXTENSION_TYPE,
+    extensionKey: SYNCED_BLOCK_SOURCE_KEY,
+    parameters: {
+      sourceDocumentAri: '',
+      contentAri: '',
+      contentPropertyKey: ''
+    },
+    localId: ''
+  };
+  return {
+    type: 'bodiedExtension',
+    attrs: attributes,
+    content: [{
+      type: 'paragraph',
+      content: [{
+        type: 'text',
+        text: 'This is a synced block. Please edit the source document to update the content.'
+      }]
+    }]
+  };
+};
+export const parseSyncedBlockContentPropertyValue = value => {
+  try {
+    if (typeof value === 'string') {
+      return JSON.parse(value);
+    }
+    return value;
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Failed to parse synced block content:', error);
+    return {
+      adf: getDefaultSyncedBlockContent()
+    };
+  }
+};
+export const stringifySyncedBlockContentPropertyValue = value => {
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Failed to serialize synced block content:', error);
+    return JSON.stringify({
+      adf: getDefaultSyncedBlockContent()
+    });
+  }
+};

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+// Entry file in package.json
+
+export { syncedBlockPlugin } from './syncedBlockPlugin';

package/dist/esm/pm-plugins/SyncClient.js

@@ -0,0 +1,160 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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) { _defineProperty(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; }
+import { JSONTransformer } from '@atlaskit/editor-json-transformer';
+import { getContentPropertyIdFromAri, getPageIdFromAri } from '../ui/extensions/synced-block/utils/ari';
+import { getContentProperty, updateContentProperty } from '../ui/extensions/synced-block/utils/content-property';
+import { parseSyncedBlockContentPropertyValue, stringifySyncedBlockContentPropertyValue } from '../ui/extensions/synced-block/utils/synced-block';
+var transformer = new JSONTransformer();
+var toJSON = function toJSON(node) {
+  return transformer.encodeNode(node);
+};
+var getCacheKey = function getCacheKey(_ref) {
+  var sourceDocumentAri = _ref.sourceDocumentAri,
+    contentAri = _ref.contentAri,
+    contentPropertyKey = _ref.contentPropertyKey;
+  return "".concat(sourceDocumentAri, "-").concat(contentAri, "-").concat(contentPropertyKey);
+};
+export var SyncClient = /*#__PURE__*/function () {
+  function SyncClient() {
+    _classCallCheck(this, SyncClient);
+    _defineProperty(this, "requestMap", new Map());
+    this.requestMap = new Map();
+  }
+  return _createClass(SyncClient, [{
+    key: "getRequestState",
+    value: function getRequestState(key) {
+      return this.requestMap.get(key);
+    }
+  }, {
+    key: "setRequestState",
+    value: function setRequestState(key, state) {
+      this.requestMap.set(key, state);
+    }
+  }, {
+    key: "sendRequest",
+    value: function () {
+      var _sendRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2) {
+        var sourceDocumentAri, contentAri, contentPropertyKey, value, pageId, contentPropertyId, contentProperty, updatedValue;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              sourceDocumentAri = _ref2.sourceDocumentAri, contentAri = _ref2.contentAri, contentPropertyKey = _ref2.contentPropertyKey, value = _ref2.value;
+              pageId = getPageIdFromAri(sourceDocumentAri);
+              contentPropertyId = getContentPropertyIdFromAri(contentAri);
+              _context.prev = 3;
+              _context.next = 6;
+              return getContentProperty({
+                pageId: pageId,
+                contentPropertyId: contentPropertyId
+              });
+            case 6:
+              contentProperty = _context.sent;
+              updatedValue = stringifySyncedBlockContentPropertyValue(_objectSpread(_objectSpread({}, parseSyncedBlockContentPropertyValue(contentProperty.value)), JSON.parse(value)));
+              _context.next = 10;
+              return updateContentProperty({
+                pageId: pageId,
+                key: contentPropertyKey,
+                value: updatedValue,
+                signal: undefined
+              });
+            case 10:
+              _context.next = 15;
+              break;
+            case 12:
+              _context.prev = 12;
+              _context.t0 = _context["catch"](3);
+              // eslint-disable-next-line no-console
+              console.error('Failed to update content property:', _context.t0);
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[3, 12]]);
+      }));
+      function sendRequest(_x) {
+        return _sendRequest.apply(this, arguments);
+      }
+      return sendRequest;
+    }()
+  }, {
+    key: "syncContent",
+    value: function syncContent(_ref3) {
+      var _this = this;
+      var sourceDocumentAri = _ref3.sourceDocumentAri,
+        contentAri = _ref3.contentAri,
+        contentPropertyKey = _ref3.contentPropertyKey,
+        node = _ref3.node;
+      var nodeAdf = toJSON(node);
+      var key = getCacheKey({
+        sourceDocumentAri: sourceDocumentAri,
+        contentAri: contentAri,
+        contentPropertyKey: contentPropertyKey
+      });
+      var value = stringifySyncedBlockContentPropertyValue({
+        adf: nodeAdf
+      });
+      var requestState = this.getRequestState(key) || {
+        timeout: null,
+        pendingValue: null,
+        isSending: false
+      };
+      requestState.pendingValue = value;
+      if (requestState.isSending) {
+        return;
+      }
+      if (requestState.timeout) {
+        clearTimeout(requestState.timeout);
+      }
+      var send = /*#__PURE__*/function () {
+        var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+          return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!requestState.isSending) {
+                  _context2.next = 2;
+                  break;
+                }
+                return _context2.abrupt("return");
+              case 2:
+                requestState.isSending = true;
+                _context2.prev = 3;
+                _context2.next = 6;
+                return _this.sendRequest({
+                  sourceDocumentAri: sourceDocumentAri,
+                  contentAri: contentAri,
+                  contentPropertyKey: contentPropertyKey,
+                  value: requestState.pendingValue || ''
+                });
+              case 6:
+                requestState.pendingValue = null;
+                _context2.next = 12;
+                break;
+              case 9:
+                _context2.prev = 9;
+                _context2.t0 = _context2["catch"](3);
+                // eslint-disable-next-line no-console
+                console.error('Failed to send synced block content:', _context2.t0);
+              case 12:
+                _context2.prev = 12;
+                requestState.isSending = false;
+                return _context2.finish(12);
+              case 15:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2, null, [[3, 9, 12, 15]]);
+        }));
+        return function send() {
+          return _ref4.apply(this, arguments);
+        };
+      }();
+      requestState.timeout = setTimeout(send, 1000);
+      this.setRequestState(key, requestState);
+    }
+  }]);
+}();

package/dist/esm/pm-plugins/main.js

@@ -0,0 +1,44 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { SyncClient } from './SyncClient';
+import { findSyncedBlockParent } from './utils';
+export var syncedBlockPluginKey = new PluginKey('syncedBlockPlugin');
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+export var createPlugin = function createPlugin() {
+  var syncClient = new SyncClient();
+  return new SafePlugin({
+    key: syncedBlockPluginKey,
+    state: {
+      init: function init() {
+        return {};
+      },
+      apply: function apply(tr, currentPluginState) {
+        if (tr.docChanged) {
+          var $pos = tr.selection.$from;
+          var syncedBlockParent = findSyncedBlockParent($pos);
+          if (syncedBlockParent) {
+            var node = syncedBlockParent.node,
+              attributes = syncedBlockParent.attributes;
+            var _attributes$parameter = attributes.parameters,
+              sourceDocumentAri = _attributes$parameter.sourceDocumentAri,
+              contentAri = _attributes$parameter.contentAri,
+              contentPropertyKey = _attributes$parameter.contentPropertyKey;
+            syncClient.syncContent({
+              sourceDocumentAri: sourceDocumentAri,
+              contentAri: contentAri,
+              contentPropertyKey: contentPropertyKey,
+              node: node
+            });
+          }
+        }
+        var meta = tr.getMeta(syncedBlockPluginKey);
+        if (meta) {
+          return meta;
+        }
+        return currentPluginState;
+      }
+    }
+  });
+};

package/dist/esm/pm-plugins/utils.js

@@ -0,0 +1,13 @@
+import { isSyncedBlockAttributes } from '../ui/extensions/synced-block/utils/synced-block';
+export var findSyncedBlockParent = function findSyncedBlockParent($pos) {
+  for (var i = 0; i <= $pos.depth; i++) {
+    var node = $pos.node(i);
+    if (isSyncedBlockAttributes(node.attrs)) {
+      return {
+        node: node,
+        attributes: node.attrs
+      };
+    }
+  }
+  return;
+};

package/dist/esm/syncedBlockPlugin.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { createPlugin } from './pm-plugins/main';
+import { GlobalStylesWrapper } from './ui/extensions/synced-block/components/GlobalStyles';
+export var syncedBlockPlugin = function syncedBlockPlugin() {
+  return {
+    name: 'syncedBlock',
+    pmPlugins: function pmPlugins() {
+      return [{
+        name: 'syncedBlockPlugin',
+        plugin: createPlugin
+      }];
+    },
+    contentComponent: function contentComponent() {
+      return /*#__PURE__*/React.createElement(GlobalStylesWrapper, null);
+    }
+  };
+};

package/dist/esm/syncedBlockPluginType.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/ui/extensions/synced-block/components/GlobalStyles.js

@@ -0,0 +1,18 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+// eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled, @atlaskit/ui-styling-standard/no-global-styles
+import { css, Global, jsx } from '@emotion/react';
+var extensionStyles = css({
+  // eslint-disable-next-line @atlaskit/ui-styling-standard/no-nested-selectors, @atlaskit/ui-styling-standard/no-unsafe-selectors
+  '[extensionkey="synced-block:reference"] .ak-renderer-wrapper > div:last-of-type': {
+    padding: "var(--ds-space-250, 20px)",
+    paddingRight: "var(--ds-space-250, 20px)"
+  }
+});
+export var GlobalStylesWrapper = function GlobalStylesWrapper() {
+  return jsx(Global, {
+    styles: [extensionStyles]
+  });
+};

package/dist/esm/ui/extensions/synced-block/components/SyncedBlockLiveView.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { useLiveSyncedBlockContent } from '../hooks/useLiveSyncedBlockContent';
+import SyncedBlockRenderer from './SyncedBlockRenderer';
+var SyncedBlockLiveView = function SyncedBlockLiveView(_ref) {
+  var sourceDocumentAri = _ref.sourceDocumentAri,
+    contentAri = _ref.contentAri;
+  var syncedBlockContent = useLiveSyncedBlockContent({
+    sourceDocumentAri: sourceDocumentAri,
+    contentAri: contentAri
+  });
+  if (!syncedBlockContent) {
+    return /*#__PURE__*/React.createElement("div", null, "Loading...");
+  }
+  return /*#__PURE__*/React.createElement(SyncedBlockRenderer, {
+    syncedBlockContent: syncedBlockContent
+  });
+};
+export default SyncedBlockLiveView;

package/dist/esm/ui/extensions/synced-block/components/SyncedBlockRenderer.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { ReactRenderer } from '@atlaskit/renderer';
+import { RendererActionsContext } from '@atlaskit/renderer/actions';
+var SyncedBlockRenderer = function SyncedBlockRenderer(_ref) {
+  var syncedBlockContent = _ref.syncedBlockContent;
+  return /*#__PURE__*/React.createElement(RendererActionsContext, null, /*#__PURE__*/React.createElement(ReactRenderer, {
+    adfStage: "stage0"
+    // @ts-ignore
+    ,
+    document: {
+      type: 'doc',
+      version: 1,
+      content: syncedBlockContent.adf.content
+    },
+    appearance: "full-page"
+  }));
+};
+export default SyncedBlockRenderer;

package/dist/esm/ui/extensions/synced-block/constants.js

@@ -0,0 +1,26 @@
+// hello.atlassian.net cloud id
+var HELLO_CLOUD_ID = 'a436116f-02ce-4520-8fbb-7301462a1674';
+
+// spike page https://hello.atlassian.net/wiki/spaces/~7120208ef57ce4d614485e876489301a16b906/pages/5626233808
+var TEST_PAGE_ID = '5626233808';
+export var getPageId = function getPageId() {
+  var _window$location$href, _window$location$href2, _window$location$path;
+  return (
+    // eslint-disable-next-line require-unicode-regexp
+    ((_window$location$href = window.location.href.match(/pageId=(\d+)/)) === null || _window$location$href === void 0 ? void 0 : _window$location$href[1]) || ( // eslint-disable-next-line require-unicode-regexp
+    (_window$location$href2 = window.location.href.match(/pages\/edit-v2\/(\d+)/)) === null || _window$location$href2 === void 0 ? void 0 : _window$location$href2[1]) || ( // eslint-disable-next-line require-unicode-regexp
+    (_window$location$path = window.location.pathname.match(/pages\/(\d+)/)) === null || _window$location$path === void 0 ? void 0 : _window$location$path[1]) ||
+    // view page or live doc
+    TEST_PAGE_ID
+  );
+};
+/**
+ * This by no means is a stable way to get the cloud id, but it works for now.
+ * We should switch passing the cloud id from Confluence to a Editor plugin,
+ * for instance the user preferences plugin would have a seperate place for user and cloud info
+ * @returns the cloud id from the initial state
+ */
+export var getCloudId = function getCloudId() {
+  var _INITIAL_STATE__;
+  return ((_INITIAL_STATE__ = window.__INITIAL_STATE__) === null || _INITIAL_STATE__ === void 0 || (_INITIAL_STATE__ = _INITIAL_STATE__.meta) === null || _INITIAL_STATE__ === void 0 ? void 0 : _INITIAL_STATE__['cloud-id']) || HELLO_CLOUD_ID;
+};

package/dist/esm/ui/extensions/synced-block/getSyncedBlockExtensionProvider.js

@@ -0,0 +1,5 @@
+import { DefaultExtensionProvider } from '@atlaskit/editor-common/extensions';
+import { getSyncedBlockManifest } from './manifest';
+export var getSyncedBlockExtensionProvider = function getSyncedBlockExtensionProvider() {
+  return new DefaultExtensionProvider([getSyncedBlockManifest()]);
+};

package/dist/esm/ui/extensions/synced-block/hooks/useLiveSyncedBlockContent.js

@@ -0,0 +1,23 @@
+import { useMemo } from 'react';
+import { usePollContentProperty } from '../hooks/usePollContentProperty';
+import { parseSyncedBlockContentPropertyValue } from '../utils/synced-block';
+export var useLiveSyncedBlockContent = function useLiveSyncedBlockContent(_ref) {
+  var sourceDocumentAri = _ref.sourceDocumentAri,
+    contentAri = _ref.contentAri;
+  var contentProperty = usePollContentProperty({
+    sourceDocumentAri: sourceDocumentAri,
+    contentAri: contentAri
+  });
+  return useMemo(function () {
+    if (!contentProperty) {
+      return null;
+    }
+    try {
+      return parseSyncedBlockContentPropertyValue(contentProperty.value);
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to extract synced block content:', error);
+      return null;
+    }
+  }, [contentProperty]);
+};

package/dist/esm/ui/extensions/synced-block/hooks/usePollContentProperty.js

@@ -0,0 +1,114 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useEffect, useRef, useState } from 'react';
+import { getContentPropertyIdFromAri, getPageIdFromAri } from '../utils/ari';
+import { getContentProperty } from '../utils/content-property';
+var POLLING_INTERVAL = 1000;
+var cache = new Map();
+var inFlightRequests = new Map();
+var subscribers = new Map();
+var pollingTimeouts = new Map();
+var lastRequestTimes = new Map();
+var getRequestKey = function getRequestKey(pageId, contentPropertyId) {
+  return "".concat(pageId, ":").concat(contentPropertyId);
+};
+var fetchContentPropertyWithDedup = function fetchContentPropertyWithDedup(pageId, contentPropertyId) {
+  var requestKey = getRequestKey(pageId, contentPropertyId);
+  lastRequestTimes.set(requestKey, Date.now());
+  var inFlightRequest = inFlightRequests.get(requestKey);
+  if (inFlightRequest) {
+    return inFlightRequest;
+  }
+  var requestPromise = getContentProperty({
+    pageId: pageId,
+    contentPropertyId: contentPropertyId
+  }).then(function (result) {
+    cache.set(requestKey, result);
+    var subscribersForKey = subscribers.get(requestKey);
+    if (subscribersForKey) {
+      subscribersForKey.forEach(function (callback) {
+        return callback(result);
+      });
+    }
+    inFlightRequests.delete(requestKey);
+    if (subscribersForKey && subscribersForKey.size > 0) {
+      scheduleNextPoll(pageId, contentPropertyId);
+    }
+    return result;
+  }).catch(function (error) {
+    inFlightRequests.delete(requestKey);
+    var subscribersForKey = subscribers.get(requestKey);
+    if (subscribersForKey && subscribersForKey.size > 0) {
+      scheduleNextPoll(pageId, contentPropertyId);
+    }
+    throw error;
+  });
+  inFlightRequests.set(requestKey, requestPromise);
+  return requestPromise;
+};
+var scheduleNextPoll = function scheduleNextPoll(pageId, contentPropertyId) {
+  var requestKey = getRequestKey(pageId, contentPropertyId);
+  var existingTimeout = pollingTimeouts.get(requestKey);
+  if (existingTimeout) {
+    clearTimeout(existingTimeout);
+  }
+  var lastRequestTime = lastRequestTimes.get(requestKey) || 0;
+  var timeElapsed = Date.now() - lastRequestTime;
+  var delay = Math.max(100, POLLING_INTERVAL - timeElapsed);
+  var timeout = setTimeout(function () {
+    var subscribersForKey = subscribers.get(requestKey);
+    if (subscribersForKey && subscribersForKey.size > 0) {
+      fetchContentPropertyWithDedup(pageId, contentPropertyId).catch(function (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to fetch content property:', error);
+      });
+    } else {
+      pollingTimeouts.delete(requestKey);
+    }
+  }, delay);
+  pollingTimeouts.set(requestKey, timeout);
+};
+export var usePollContentProperty = function usePollContentProperty(_ref) {
+  var sourceDocumentAri = _ref.sourceDocumentAri,
+    contentAri = _ref.contentAri;
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    contentProperty = _useState2[0],
+    setContentProperty = _useState2[1];
+  var initializedRef = useRef(false);
+  useEffect(function () {
+    var pageId = getPageIdFromAri(sourceDocumentAri);
+    var contentPropertyId = getContentPropertyIdFromAri(contentAri);
+    var requestKey = getRequestKey(pageId, contentPropertyId);
+    var subscribersForKey = subscribers.get(requestKey) || new Set();
+    if (!subscribers.has(requestKey)) {
+      subscribers.set(requestKey, subscribersForKey);
+    }
+    subscribersForKey.add(setContentProperty);
+    var cachedValue = cache.get(requestKey);
+    if (cachedValue) {
+      setContentProperty(cachedValue);
+    }
+    if (subscribersForKey.size === 1 || !initializedRef.current) {
+      initializedRef.current = true;
+      fetchContentPropertyWithDedup(pageId, contentPropertyId).catch(function (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to fetch content property:', error);
+      });
+    }
+    return function () {
+      subscribersForKey.delete(setContentProperty);
+      if (subscribersForKey.size === 0) {
+        subscribers.delete(requestKey);
+        var existingTimeout = pollingTimeouts.get(requestKey);
+        if (existingTimeout) {
+          clearTimeout(existingTimeout);
+          pollingTimeouts.delete(requestKey);
+        }
+      }
+    };
+  }, [sourceDocumentAri, contentAri]);
+  var pageId = getPageIdFromAri(sourceDocumentAri);
+  var contentPropertyId = getContentPropertyIdFromAri(contentAri);
+  var requestKey = getRequestKey(pageId, contentPropertyId);
+  return contentProperty || cache.get(requestKey);
+};

package/dist/esm/ui/extensions/synced-block/index.js

@@ -0,0 +1,5 @@
+// Disable no-re-export rule for entry point files
+/* eslint-disable @atlaskit/editor/no-re-export */
+
+export { getSyncedBlockExtensionProvider } from './getSyncedBlockExtensionProvider';
+export { getSyncedBlockManifest } from './manifest';