@atlaskit/editor-plugin-synced-block 0.1.0

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

@@ -0,0 +1,247 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import React from 'react';
+import SmartLinkIcon from '@atlaskit/icon/core/smart-link';
+import SyncedBlockLiveView from './components/SyncedBlockLiveView';
+import { getPageId } from './constants';
+import { getConfluencePageAri, getContentPropertyAri } from './utils/ari';
+import { createContentProperty } from './utils/content-property';
+import { SYNCED_BLOCK_EXTENSION_KEY, SYNCED_BLOCK_EXTENSION_TYPE, SYNCED_BLOCK_REFERENCE_KEY, SYNCED_BLOCK_REFERENCE_NODE, SYNCED_BLOCK_SOURCE_KEY, SYNCED_BLOCK_SOURCE_NODE, getDefaultSyncedBlockContent, isSyncedBlockAttributes, stringifySyncedBlockContentPropertyValue } from './utils/synced-block';
+var getRandomId = function getRandomId() {
+  if (!globalThis.crypto || typeof globalThis.crypto.randomUUID !== 'function') {
+    return new Date().toISOString();
+  }
+  return globalThis.crypto.randomUUID();
+};
+
+// Remaining tasks
+// - Better location for content sync implementation – currently done in SyncedBlockSource renderer which won't work in editor
+// 		- Could implement an editor plugin to do this, if there's no native way to do it with extensions
+// - Implement separate content property for storage of the metadata of a synced block, separate from the content
+// 		- Update polling to use the metadata content property, then if metadata updated, fetch the content property
+// - Investigate re-rendering of SyncedBlockReference in editor on every document change (is this just atlaskit behavior?)
+// - On copy of the synced block, transform into a reference
+// - Move implementation into Confluence and test in branch environment
+// - Dealing with orphaned synced block content properties data
+// - Getting current page id in editor context and the cloud id
+// - Explore hiding the frame for the extension in the editor, currently using `__hideFrame: true` and commented code to enable
+export var getSyncedBlockManifest = function getSyncedBlockManifest() {
+  return {
+    title: 'Synced Block',
+    type: SYNCED_BLOCK_EXTENSION_TYPE,
+    key: SYNCED_BLOCK_EXTENSION_KEY,
+    description: 'Synced block spike',
+    icons: {
+      // Ignored via go/ees005
+      // eslint-disable-next-line require-await
+      '48': function () {
+        var _2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+          return _regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return", function () {
+                  return /*#__PURE__*/React.createElement(SmartLinkIcon, {
+                    label: "Synced Block",
+                    size: "medium"
+                  });
+                });
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        function _() {
+          return _2.apply(this, arguments);
+        }
+        return _;
+      }()
+    },
+    modules: {
+      quickInsert: [{
+        key: 'quick-insert-synced-block-source',
+        action: function () {
+          var _action = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_api) {
+            var contentPropertyKey, content, value, contentProperty, attributes;
+            return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+              while (1) switch (_context2.prev = _context2.next) {
+                case 0:
+                  contentPropertyKey = "synced-block-" + getRandomId();
+                  content = getDefaultSyncedBlockContent();
+                  value = stringifySyncedBlockContentPropertyValue({
+                    adf: content
+                  });
+                  _context2.next = 5;
+                  return createContentProperty({
+                    pageId: getPageId(),
+                    key: contentPropertyKey,
+                    value: value
+                  });
+                case 5:
+                  contentProperty = _context2.sent;
+                  attributes = {
+                    extensionType: SYNCED_BLOCK_EXTENSION_TYPE,
+                    extensionKey: SYNCED_BLOCK_SOURCE_KEY,
+                    parameters: {
+                      sourceDocumentAri: getConfluencePageAri(getPageId()),
+                      contentAri: getContentPropertyAri(contentProperty.id),
+                      contentPropertyKey: contentPropertyKey
+                    },
+                    localId: 'testId'
+                  };
+                  content.attrs = attributes;
+                  return _context2.abrupt("return", content);
+                case 9:
+                case "end":
+                  return _context2.stop();
+              }
+            }, _callee2);
+          }));
+          function action(_x) {
+            return _action.apply(this, arguments);
+          }
+          return action;
+        }()
+      }],
+      nodes: _defineProperty(_defineProperty({}, SYNCED_BLOCK_SOURCE_NODE, {
+        type: 'bodiedExtension',
+        // Ignored via go/ees005
+        // eslint-disable-next-line require-await
+        render: function () {
+          var _render = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  return _context3.abrupt("return", function (props) {
+                    if (!isSyncedBlockAttributes(props.node)) {
+                      return null;
+                    }
+                    var _props$node$parameter = props.node.parameters,
+                      sourceDocumentAri = _props$node$parameter.sourceDocumentAri,
+                      contentAri = _props$node$parameter.contentAri;
+                    return /*#__PURE__*/React.createElement(SyncedBlockLiveView, {
+                      sourceDocumentAri: sourceDocumentAri,
+                      contentAri: contentAri
+                    });
+                  });
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          }));
+          function render() {
+            return _render.apply(this, arguments);
+          }
+          return render;
+        }(),
+        // @ts-expect-error
+        __hideFrame: true
+      }), SYNCED_BLOCK_REFERENCE_NODE, {
+        type: 'extension',
+        // Ignored via go/ees005
+        // eslint-disable-next-line require-await
+        render: function () {
+          var _render2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+            return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  return _context4.abrupt("return", function (props) {
+                    if (!isSyncedBlockAttributes(props.node)) {
+                      return null;
+                    }
+                    var _props$node$parameter2 = props.node.parameters,
+                      sourceDocumentAri = _props$node$parameter2.sourceDocumentAri,
+                      contentAri = _props$node$parameter2.contentAri;
+                    return /*#__PURE__*/React.createElement(SyncedBlockLiveView, {
+                      sourceDocumentAri: sourceDocumentAri,
+                      contentAri: contentAri
+                    });
+                  });
+                case 1:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4);
+          }));
+          function render() {
+            return _render2.apply(this, arguments);
+          }
+          return render;
+        }(),
+        // @ts-expect-error
+        __hideFrame: true
+      }),
+      contextualToolbars: [{
+        context: {
+          type: 'extension',
+          nodeType: 'bodiedExtension',
+          extensionType: SYNCED_BLOCK_EXTENSION_TYPE,
+          extensionKey: SYNCED_BLOCK_SOURCE_KEY
+        },
+        toolbarItems: [{
+          key: 'toolbar-item-key',
+          label: 'Referenece',
+          display: 'icon',
+          tooltip: 'Create reference',
+          // Ignored via go/ees005
+          // eslint-disable-next-line require-await
+          icon: function () {
+            var _icon = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+              return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+                while (1) switch (_context5.prev = _context5.next) {
+                  case 0:
+                    return _context5.abrupt("return", function () {
+                      return /*#__PURE__*/React.createElement(SmartLinkIcon, {
+                        label: "Synced Block",
+                        size: "medium"
+                      });
+                    });
+                  case 1:
+                  case "end":
+                    return _context5.stop();
+                }
+              }, _callee5);
+            }));
+            function icon() {
+              return _icon.apply(this, arguments);
+            }
+            return icon;
+          }(),
+          // Ignored via go/ees005
+          // eslint-disable-next-line require-await
+          action: function () {
+            var _action2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(contextNode, api) {
+              var _contextNode$attrs, _contextNode$attrs2, _contextNode$attrs3;
+              return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+                while (1) switch (_context6.prev = _context6.next) {
+                  case 0:
+                    api.doc.insertAfter((_contextNode$attrs = contextNode.attrs) === null || _contextNode$attrs === void 0 ? void 0 : _contextNode$attrs.localId, {
+                      type: 'extension',
+                      attrs: {
+                        extensionType: SYNCED_BLOCK_EXTENSION_TYPE,
+                        extensionKey: SYNCED_BLOCK_REFERENCE_KEY,
+                        parameters: {
+                          sourceDocumentAri: (_contextNode$attrs2 = contextNode.attrs) === null || _contextNode$attrs2 === void 0 || (_contextNode$attrs2 = _contextNode$attrs2.parameters) === null || _contextNode$attrs2 === void 0 ? void 0 : _contextNode$attrs2.sourceDocumentAri,
+                          contentAri: (_contextNode$attrs3 = contextNode.attrs) === null || _contextNode$attrs3 === void 0 || (_contextNode$attrs3 = _contextNode$attrs3.parameters) === null || _contextNode$attrs3 === void 0 ? void 0 : _contextNode$attrs3.contentAri
+                        },
+                        localId: 'testId'
+                      }
+                    });
+                  case 1:
+                  case "end":
+                    return _context6.stop();
+                }
+              }, _callee6);
+            }));
+            function action(_x2, _x3) {
+              return _action2.apply(this, arguments);
+            }
+            return action;
+          }()
+        }]
+      }]
+    }
+  };
+};

package/dist/esm/ui/extensions/synced-block/utils/ari.js

@@ -0,0 +1,23 @@
+import { getCloudId } from '../constants';
+export var getConfluencePageAri = function getConfluencePageAri(pageId) {
+  return "ari:cloud:confluence:".concat(getCloudId(), ":page/").concat(pageId);
+};
+export var getPageIdFromAri = function getPageIdFromAri(ari) {
+  // eslint-disable-next-line require-unicode-regexp
+  var match = ari.match(/ari:cloud:confluence:[^:]+:page\/(\d+)/);
+  if (match) {
+    return match[1];
+  }
+  throw new Error("Invalid page ARI: ".concat(ari));
+};
+export var getContentPropertyAri = function getContentPropertyAri(contentPropertyId) {
+  return "ari:cloud:confluence:".concat(getCloudId(), ":content/").concat(contentPropertyId);
+};
+export var getContentPropertyIdFromAri = function getContentPropertyIdFromAri(ari) {
+  // eslint-disable-next-line require-unicode-regexp
+  var match = ari.match(/ari:cloud:confluence:[^:]+:content\/([^/]+)/);
+  if (match) {
+    return match[1];
+  }
+  throw new Error("Invalid content property ARI: ".concat(ari));
+};

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

@@ -0,0 +1,153 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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';
+var BASE_URL = "/gateway/api/ex/confluence/".concat(getCloudId());
+var API_BASE_URL = "".concat(BASE_URL, "/wiki/api/v2");
+var COMMON_HEADERS = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json'
+};
+var getContentPropertiesUrl = function getContentPropertiesUrl(_ref) {
+  var pageId = _ref.pageId,
+    contentPropertyId = _ref.contentPropertyId;
+  var url = "".concat(API_BASE_URL, "/pages/").concat(pageId, "/properties");
+  if (contentPropertyId) {
+    return "".concat(url, "/").concat(contentPropertyId);
+  }
+  return url;
+};
+var getGraphQLPropertiesUrl = function getGraphQLPropertiesUrl() {
+  return "/cgraphql/api/graphql";
+};
+export var createContentProperty = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2) {
+    var pageId, key, value, url, body, response, contentProperty;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          pageId = _ref2.pageId, key = _ref2.key, value = _ref2.value;
+          url = getContentPropertiesUrl({
+            pageId: pageId
+          });
+          body = JSON.stringify({
+            key: key,
+            value: value
+          });
+          _context.next = 5;
+          return fetch(url, {
+            method: 'POST',
+            headers: COMMON_HEADERS,
+            body: body
+          });
+        case 5:
+          response = _context.sent;
+          if (response.ok) {
+            _context.next = 8;
+            break;
+          }
+          throw new Error("Failed to create content property: ".concat(response.statusText));
+        case 8:
+          _context.next = 10;
+          return response.json();
+        case 10:
+          contentProperty = _context.sent;
+          return _context.abrupt("return", contentProperty);
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function createContentProperty(_x) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var getContentProperty = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref4) {
+    var pageId, contentPropertyId, signal, url, response, contentProperty;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          pageId = _ref4.pageId, contentPropertyId = _ref4.contentPropertyId, signal = _ref4.signal;
+          url = getContentPropertiesUrl({
+            pageId: pageId,
+            contentPropertyId: contentPropertyId
+          });
+          _context2.next = 4;
+          return fetch(url, {
+            method: 'GET',
+            headers: COMMON_HEADERS,
+            signal: signal
+          });
+        case 4:
+          response = _context2.sent;
+          if (response.ok) {
+            _context2.next = 7;
+            break;
+          }
+          throw new Error("Failed to get content property: ".concat(response.statusText));
+        case 7:
+          _context2.next = 9;
+          return response.json();
+        case 9:
+          contentProperty = _context2.sent;
+          return _context2.abrupt("return", contentProperty);
+        case 11:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function getContentProperty(_x2) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+var getQuery = function getQuery(documentARI, key, value) {
+  return "mutation {\n\t  confluence {\n\t    updateValuePageProperty(input: {\n\t      pageId: \"".concat(documentARI, "\",\n\t      key: \"").concat(key, "\",\n\t      value: \"").concat(value, "\",\n\t      useSameVersion: true\n\t    }) {\n\t      pageProperty {\n\t        key,\n\t        value\n\t      }\n\t    }\n\t  }\n\t}");
+};
+export var updateContentProperty = /*#__PURE__*/function () {
+  var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref6) {
+    var pageId, key, value, url, documentARI, query, bodyData, response, contentProperty;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          pageId = _ref6.pageId, key = _ref6.key, value = _ref6.value;
+          url = getGraphQLPropertiesUrl();
+          documentARI = getConfluencePageAri(pageId); // eslint-disable-next-line require-unicode-regexp
+          query = getQuery(documentARI, key, value.replace(/"/g, '\\"'));
+          bodyData = {
+            query: query
+          };
+          _context3.next = 7;
+          return fetch(url, {
+            method: 'POST',
+            headers: COMMON_HEADERS,
+            body: JSON.stringify(bodyData)
+          });
+        case 7:
+          response = _context3.sent;
+          if (response.ok) {
+            _context3.next = 10;
+            break;
+          }
+          throw new Error("Failed to update content property: ".concat(response.statusText));
+        case 10:
+          _context3.next = 12;
+          return response.json();
+        case 12:
+          contentProperty = _context3.sent;
+          return _context3.abrupt("return", contentProperty);
+        case 14:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function updateContentProperty(_x3) {
+    return _ref7.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,58 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+export var SYNCED_BLOCK_EXTENSION_TYPE = 'com.atlassian.platform.extensions';
+export var SYNCED_BLOCK_EXTENSION_KEY = 'synced-block';
+export var SYNCED_BLOCK_SOURCE_NODE = 'source';
+export var SYNCED_BLOCK_SOURCE_KEY = "".concat(SYNCED_BLOCK_EXTENSION_KEY, ":").concat(SYNCED_BLOCK_SOURCE_NODE);
+export var SYNCED_BLOCK_REFERENCE_NODE = 'reference';
+export var SYNCED_BLOCK_REFERENCE_KEY = "".concat(SYNCED_BLOCK_EXTENSION_KEY, ":").concat(SYNCED_BLOCK_REFERENCE_NODE);
+export var isSyncedBlockAttributes = function isSyncedBlockAttributes(attributes) {
+  return !!attributes && _typeof(attributes) === 'object' && 'extensionKey' in attributes && (attributes.extensionKey === SYNCED_BLOCK_SOURCE_KEY || attributes.extensionKey === SYNCED_BLOCK_REFERENCE_KEY);
+};
+export var getDefaultSyncedBlockContent = function getDefaultSyncedBlockContent() {
+  var 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 var parseSyncedBlockContentPropertyValue = function 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 var stringifySyncedBlockContentPropertyValue = function 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/types/index.d.ts

@@ -0,0 +1,3 @@
+export { syncedBlockPlugin } from './syncedBlockPlugin';
+export type { SyncedBlockPlugin } from './syncedBlockPluginType';
+export type { SyncedBlockPluginOptions } from './types';

package/dist/types/pm-plugins/SyncClient.d.ts

@@ -0,0 +1,14 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+export declare class SyncClient {
+    private requestMap;
+    constructor();
+    private getRequestState;
+    private setRequestState;
+    private sendRequest;
+    syncContent({ sourceDocumentAri, contentAri, contentPropertyKey, node, }: {
+        contentAri: string;
+        contentPropertyKey: string;
+        node: PMNode;
+        sourceDocumentAri: string;
+    }): void;
+}

package/dist/types/pm-plugins/main.d.ts

@@ -0,0 +1,6 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const syncedBlockPluginKey: PluginKey<any>;
+type SyncedBlockPluginState = {};
+export declare const createPlugin: () => SafePlugin<SyncedBlockPluginState>;
+export {};

package/dist/types/pm-plugins/utils.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+export declare const findSyncedBlockParent: ($pos: ResolvedPos) => {
+    node: import("prosemirror-model").Node;
+    attributes: import("../ui/extensions/synced-block/utils/synced-block").SyncedBlockAttributes;
+} | undefined;

package/dist/types/syncedBlockPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { SyncedBlockPlugin } from './syncedBlockPluginType';
+export declare const syncedBlockPlugin: SyncedBlockPlugin;

package/dist/types/syncedBlockPluginType.d.ts

@@ -0,0 +1,2 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+export type SyncedBlockPlugin = NextEditorPlugin<'syncedBlock'>;

package/dist/types/types/index.d.ts

@@ -0,0 +1,3 @@
+export type SyncedBlockPluginOptions = {
+    clouldId?: string;
+};

package/dist/types/ui/extensions/synced-block/components/GlobalStyles.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { jsx } from '@emotion/react';
+export declare const GlobalStylesWrapper: () => jsx.JSX.Element;

package/dist/types/ui/extensions/synced-block/components/SyncedBlockLiveView.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type SyncedBlockLiveView = {
+    contentAri: string;
+    sourceDocumentAri: string;
+};
+declare const SyncedBlockLiveView: ({ sourceDocumentAri, contentAri }: SyncedBlockLiveView) => React.JSX.Element;
+export default SyncedBlockLiveView;

package/dist/types/ui/extensions/synced-block/components/SyncedBlockRenderer.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { SyncedBlockContentPropertyValue } from '../utils/synced-block';
+type SyncedBlockRenderer = {
+    syncedBlockContent: SyncedBlockContentPropertyValue;
+};
+declare const SyncedBlockRenderer: ({ syncedBlockContent }: SyncedBlockRenderer) => React.JSX.Element;
+export default SyncedBlockRenderer;

package/dist/types/ui/extensions/synced-block/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const getPageId: () => string;
+/**
+ * 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 declare const getCloudId: () => string;

package/dist/types/ui/extensions/synced-block/getSyncedBlockExtensionProvider.d.ts

@@ -0,0 +1,2 @@
+import { DefaultExtensionProvider } from '@atlaskit/editor-common/extensions';
+export declare const getSyncedBlockExtensionProvider: () => DefaultExtensionProvider<import("@atlaskit/editor-common/extensions").Parameters>;

package/dist/types/ui/extensions/synced-block/hooks/useLiveSyncedBlockContent.d.ts

@@ -0,0 +1,6 @@
+type UseLiveSyncedBlockContentOptions = {
+    contentAri: string;
+    sourceDocumentAri: string;
+};
+export declare const useLiveSyncedBlockContent: ({ sourceDocumentAri, contentAri, }: UseLiveSyncedBlockContentOptions) => import("../utils/synced-block").SyncedBlockContentPropertyValue | null;
+export {};

package/dist/types/ui/extensions/synced-block/hooks/usePollContentProperty.d.ts

@@ -0,0 +1,7 @@
+import type { ContentProperty } from '../utils/content-property';
+type UsePollContentPropertyOptions = {
+    contentAri: string;
+    sourceDocumentAri: string;
+};
+export declare const usePollContentProperty: ({ sourceDocumentAri, contentAri, }: UsePollContentPropertyOptions) => ContentProperty | undefined;
+export {};

package/dist/types/ui/extensions/synced-block/index.d.ts

@@ -0,0 +1,2 @@
+export { getSyncedBlockExtensionProvider } from './getSyncedBlockExtensionProvider';
+export { getSyncedBlockManifest } from './manifest';

package/dist/types/ui/extensions/synced-block/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionManifest } from '@atlaskit/editor-common/extensions';
+export declare const getSyncedBlockManifest: () => ExtensionManifest;

package/dist/types/ui/extensions/synced-block/utils/ari.d.ts

@@ -0,0 +1,4 @@
+export declare const getConfluencePageAri: (pageId: string) => string;
+export declare const getPageIdFromAri: (ari: string) => string;
+export declare const getContentPropertyAri: (contentPropertyId: string) => string;
+export declare const getContentPropertyIdFromAri: (ari: string) => string;

package/dist/types/ui/extensions/synced-block/utils/content-property.d.ts

@@ -0,0 +1,33 @@
+export type ContentProperty = {
+    id: string;
+    key: string;
+    value: string;
+    version: ContentPropertyVersion;
+};
+type ContentPropertyVersion = {
+    authorId: string;
+    createdAt: string;
+    message: string;
+    minorEdit: boolean;
+    number: number;
+};
+type CreateContentPropertyOptions = {
+    key: string;
+    pageId: string;
+    value: string;
+};
+export declare const createContentProperty: ({ pageId, key, value, }: CreateContentPropertyOptions) => Promise<ContentProperty>;
+type GetContentPropertyOptions = {
+    contentPropertyId: string;
+    pageId: string;
+    signal?: AbortSignal;
+};
+export declare const getContentProperty: ({ pageId, contentPropertyId, signal, }: GetContentPropertyOptions) => Promise<ContentProperty>;
+type UpdateContentPropertyOptions = {
+    key: string;
+    pageId: string;
+    signal?: AbortSignal;
+    value: string;
+};
+export declare const updateContentProperty: ({ pageId, key, value, }: UpdateContentPropertyOptions) => Promise<ContentProperty>;
+export {};

package/dist/types/ui/extensions/synced-block/utils/synced-block.d.ts

@@ -0,0 +1,24 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+export declare const SYNCED_BLOCK_EXTENSION_TYPE = "com.atlassian.platform.extensions";
+export declare const SYNCED_BLOCK_EXTENSION_KEY = "synced-block";
+export declare const SYNCED_BLOCK_SOURCE_NODE = "source";
+export declare const SYNCED_BLOCK_SOURCE_KEY = "synced-block:source";
+export declare const SYNCED_BLOCK_REFERENCE_NODE = "reference";
+export declare const SYNCED_BLOCK_REFERENCE_KEY = "synced-block:reference";
+export type SyncedBlockAttributes = {
+    extensionKey: typeof SYNCED_BLOCK_SOURCE_KEY | typeof SYNCED_BLOCK_REFERENCE_KEY;
+    extensionType: typeof SYNCED_BLOCK_EXTENSION_TYPE;
+    localId: string;
+    parameters: {
+        contentAri: string;
+        contentPropertyKey: string;
+        sourceDocumentAri: string;
+    };
+};
+export declare const isSyncedBlockAttributes: (attributes: unknown) => attributes is SyncedBlockAttributes;
+export type SyncedBlockContentPropertyValue = {
+    adf: ADFEntity;
+};
+export declare const getDefaultSyncedBlockContent: () => ADFEntity;
+export declare const parseSyncedBlockContentPropertyValue: (value: string | object) => SyncedBlockContentPropertyValue;
+export declare const stringifySyncedBlockContentPropertyValue: (value: SyncedBlockContentPropertyValue) => string;

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

@@ -0,0 +1,3 @@
+export { syncedBlockPlugin } from './syncedBlockPlugin';
+export type { SyncedBlockPlugin } from './syncedBlockPluginType';
+export type { SyncedBlockPluginOptions } from './types';