@atlaskit/editor-synced-block-provider 2.1.2 → 2.2.1

package/dist/esm/store-manager/sourceSyncBlockStoreManager.js

@@ -0,0 +1,184 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import uuid from 'uuid';
+import { rebaseTransaction as _rebaseTransaction } from '../common/rebase-transaction';
+import { resourceIdFromSourceAndLocalId } from '../utils/ari';
+import { convertSyncBlockPMNodeToSyncBlockData } from '../utils/utils';
+export var SourceSyncBlockStoreManager = /*#__PURE__*/function () {
+  function SourceSyncBlockStoreManager(dataProvider) {
+    _classCallCheck(this, SourceSyncBlockStoreManager);
+    this.dataProvider = dataProvider;
+    this.syncBlockCache = new Map();
+  }
+
+  /**
+   * Add/update a sync block node to/from the local cache
+   * @param syncBlockNode - The sync block node to update
+   */
+  return _createClass(SourceSyncBlockStoreManager, [{
+    key: "updateSyncBlockData",
+    value: function updateSyncBlockData(syncBlockNode) {
+      try {
+        var _syncBlockNode$attrs = syncBlockNode.attrs,
+          localId = _syncBlockNode$attrs.localId,
+          resourceId = _syncBlockNode$attrs.resourceId;
+        if (!localId || !resourceId) {
+          throw new Error('Local ID or resource ID is not set');
+        }
+        var syncBlockData = convertSyncBlockPMNodeToSyncBlockData(syncBlockNode);
+        this.syncBlockCache.set(localId, syncBlockData);
+      } catch (_unused) {
+        //TODO: EDITOR-1921 - add error analytics
+      }
+    }
+
+    /**
+     * Save content of bodiedSyncBlock nodes in local cache to backend
+     *
+     * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+     */
+  }, {
+    key: "flushBodiedSyncBlocks",
+    value: (function () {
+      var _flushBodiedSyncBlocks = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var bodiedSyncBlockNodes, bodiedSyncBlockData, resourceIds;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              if (this.dataProvider) {
+                _context.next = 3;
+                break;
+              }
+              throw new Error('Data provider not set');
+            case 3:
+              bodiedSyncBlockNodes = [];
+              bodiedSyncBlockData = [];
+              Array.from(this.syncBlockCache.values()).forEach(function (syncBlockData) {
+                bodiedSyncBlockNodes.push({
+                  type: 'bodiedSyncBlock',
+                  attrs: {
+                    localId: syncBlockData.blockInstanceId,
+                    resourceId: syncBlockData.resourceId
+                  }
+                });
+                bodiedSyncBlockData.push(syncBlockData);
+              });
+              if (!(bodiedSyncBlockNodes.length === 0)) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", Promise.resolve(true));
+            case 8:
+              _context.next = 10;
+              return this.dataProvider.writeNodesData(bodiedSyncBlockNodes, bodiedSyncBlockData);
+            case 10:
+              resourceIds = _context.sent;
+              return _context.abrupt("return", resourceIds.every(function (resourceId) {
+                return resourceId !== undefined;
+              }));
+            case 14:
+              _context.prev = 14;
+              _context.t0 = _context["catch"](0);
+              return _context.abrupt("return", false);
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 14]]);
+      }));
+      function flushBodiedSyncBlocks() {
+        return _flushBodiedSyncBlocks.apply(this, arguments);
+      }
+      return flushBodiedSyncBlocks;
+    }())
+  }, {
+    key: "setEditorView",
+    value: function setEditorView(editorView) {
+      this.editorView = editorView;
+    }
+  }, {
+    key: "registerConfirmationCallback",
+    value: function registerConfirmationCallback(callback) {
+      var _this = this;
+      this.confirmationCallback = callback;
+      return function () {
+        _this.confirmationCallback = undefined;
+      };
+    }
+  }, {
+    key: "requireConfirmationBeforeDelete",
+    value: function requireConfirmationBeforeDelete() {
+      return !!this.confirmationCallback;
+    }
+  }, {
+    key: "createSyncBlockNode",
+    value: function createSyncBlockNode() {
+      var _this$dataProvider;
+      var blockInstanceId = uuid();
+      var sourceId = (_this$dataProvider = this.dataProvider) === null || _this$dataProvider === void 0 ? void 0 : _this$dataProvider.getSourceId();
+      if (!sourceId) {
+        throw new Error('Provider of sync block plugin is not set');
+      }
+
+      // This should be generated by the data provider implementation as it differs between data providers
+      var resourceId = resourceIdFromSourceAndLocalId(sourceId, blockInstanceId);
+      var syncBlockNode = {
+        attrs: {
+          resourceId: resourceId,
+          localId: blockInstanceId
+        },
+        type: 'bodiedSyncBlock'
+      };
+      return syncBlockNode;
+    }
+  }, {
+    key: "deleteSyncBlocksWithConfirmation",
+    value: function () {
+      var _deleteSyncBlocksWithConfirmation = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(tr, syncBlockIds) {
+        var _this2 = this;
+        var confirmed, _this$editorView;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!this.confirmationCallback) {
+                _context2.next = 7;
+                break;
+              }
+              this.confirmationTransaction = tr;
+              _context2.next = 4;
+              return this.confirmationCallback();
+            case 4:
+              confirmed = _context2.sent;
+              if (confirmed) {
+                (_this$editorView = this.editorView) === null || _this$editorView === void 0 || _this$editorView.dispatch(this.confirmationTransaction.setMeta('isConfirmedSyncBlockDeletion', true));
+                // Need to update the BE on deletion
+                syncBlockIds.forEach(function (_ref) {
+                  var localId = _ref.localId;
+                  return _this2.syncBlockCache.delete(localId);
+                });
+              }
+              this.confirmationTransaction = undefined;
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function deleteSyncBlocksWithConfirmation(_x, _x2) {
+        return _deleteSyncBlocksWithConfirmation.apply(this, arguments);
+      }
+      return deleteSyncBlocksWithConfirmation;
+    }()
+  }, {
+    key: "rebaseTransaction",
+    value: function rebaseTransaction(incomingTr, state) {
+      if (!this.confirmationTransaction) {
+        return;
+      }
+      this.confirmationTransaction = _rebaseTransaction(this.confirmationTransaction, incomingTr, state);
+    }
+  }]);
+}();

package/dist/esm/store-manager/syncBlockStoreManager.js

@@ -0,0 +1,105 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { ReferenceSyncBlockStoreManager } from './referenceSyncBlockStoreManager';
+import { SourceSyncBlockStoreManager } from './sourceSyncBlockStoreManager';
+
+// A store manager responsible for the lifecycle and state management of sync blocks in an editor instance.
+// Supports create, read, update, and delete operations for sync blocks.
+// Designed to manage local in-memory state and synchronize with an external data provider.
+// Handles caching, debouncing updates, and publish/subscribe for local changes.
+// Ensures consistency between local and remote state, and can be used in both editor and renderer contexts.
+export var SyncBlockStoreManager = /*#__PURE__*/function () {
+  function SyncBlockStoreManager(dataProvider) {
+    _classCallCheck(this, SyncBlockStoreManager);
+    this.referenceSyncBlockStoreManager = new ReferenceSyncBlockStoreManager(dataProvider);
+    this.sourceSyncBlockStoreManager = new SourceSyncBlockStoreManager(dataProvider);
+  }
+  return _createClass(SyncBlockStoreManager, [{
+    key: "fetchSyncBlockData",
+    value: function fetchSyncBlockData(syncBlockNode) {
+      if (this.isSourceBlock(syncBlockNode)) {
+        return Promise.reject(new Error('Invalid sync block node type provided for fetchSyncBlockData'));
+      }
+      return this.referenceSyncBlockStoreManager.fetchSyncBlockData(syncBlockNode);
+    }
+
+    /**
+     * Add/update a sync block node to/from the local cache
+     * @param syncBlockNode - The sync block node to update
+     */
+  }, {
+    key: "updateSyncBlockData",
+    value: function updateSyncBlockData(syncBlockNode) {
+      if (this.isSourceBlock(syncBlockNode)) {
+        this.sourceSyncBlockStoreManager.updateSyncBlockData(syncBlockNode);
+      } else {
+        throw new Error('Invalid sync block node type provided for updateSyncBlockData');
+      }
+    }
+
+    /**
+     * Save content of bodiedSyncBlock nodes in local cache to backend
+     *
+     * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+     */
+  }, {
+    key: "flushBodiedSyncBlocks",
+    value: function flushBodiedSyncBlocks() {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.flushBodiedSyncBlocks();
+    }
+
+    /**
+     * Get the URL for a sync block.
+     * @param localId - The local ID of the sync block to get the URL for
+     * @returns
+     */
+  }, {
+    key: "getSyncBlockURL",
+    value: function getSyncBlockURL(localId) {
+      // only applicable to reference sync block, for now (will be refactored further)
+      return this.referenceSyncBlockStoreManager.getSyncBlockURL(localId);
+    }
+  }, {
+    key: "setEditorView",
+    value: function setEditorView(editorView) {
+      // only applicable to source sync block, for now (will be refactored further)
+      this.sourceSyncBlockStoreManager.setEditorView(editorView);
+    }
+  }, {
+    key: "isSourceBlock",
+    value: function isSourceBlock(node) {
+      return node.type.name === 'bodiedSyncBlock';
+    }
+  }, {
+    key: "registerConfirmationCallback",
+    value: function registerConfirmationCallback(callback) {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.registerConfirmationCallback(callback);
+    }
+  }, {
+    key: "requireConfirmationBeforeDelete",
+    value: function requireConfirmationBeforeDelete() {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.requireConfirmationBeforeDelete();
+    }
+  }, {
+    key: "createSyncBlockNode",
+    value: function createSyncBlockNode() {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.createSyncBlockNode();
+    }
+  }, {
+    key: "deleteSyncBlocksWithConfirmation",
+    value: function deleteSyncBlocksWithConfirmation(tr, syncBlockIds) {
+      // only applicable to source sync block, for now (will be refactored further)
+      return this.sourceSyncBlockStoreManager.deleteSyncBlocksWithConfirmation(tr, syncBlockIds);
+    }
+  }, {
+    key: "rebaseTransaction",
+    value: function rebaseTransaction(incomingTr, state) {
+      // only applicable to source sync block, for now (will be refactored further)
+      this.sourceSyncBlockStoreManager.rebaseTransaction(incomingTr, state);
+    }
+  }]);
+}();

package/dist/esm/utils/utils.js

@@ -1,19 +1,3 @@
-import { JSONTransformer } from '@atlaskit/editor-json-transformer';
-export var convertSyncBlockPMNodeToSyncBlockNode = function convertSyncBlockPMNodeToSyncBlockNode(node) {
-  var includeContent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var transformer = new JSONTransformer();
-  var toJSON = function toJSON(node) {
-    return transformer.encodeNode(node);
-  };
-  return {
-    type: 'syncBlock',
-    attrs: {
-      localId: node.attrs.localId,
-      resourceId: node.attrs.resourceId
-    },
-    content: includeContent ? node.content.content.map(toJSON) : undefined
-  };
-};
 export var convertSyncBlockPMNodeToSyncBlockData = function convertSyncBlockPMNodeToSyncBlockData(node) {
   return {
     blockInstanceId: node.attrs.localId,

package/dist/types/common/types.d.ts

@@ -1,42 +1,29 @@
 import type { ADFEntity } from '@atlaskit/adf-utils/types';
 import type { JSONNode } from '@atlaskit/editor-json-transformer/types';
-import { NodeDataProvider } from '@atlaskit/node-data-provider';
+export type BlockInstanceId = string;
+export type ResourceId = string;
 export type SyncBlockAttrs = {
-    localId: string;
-    resourceId: string;
+    localId: BlockInstanceId;
+    resourceId: ResourceId;
 };
-export type SyncBlockNode = {
+export interface SyncBlockNode extends JSONNode {
     attrs: SyncBlockAttrs;
-    content?: Array<JSONNode>;
-    type: 'syncBlock';
-};
+    content?: Array<JSONNode | undefined>;
+    type: 'syncBlock' | 'bodiedSyncBlock';
+}
 export declare enum SyncBlockStatus {
     Errored = "errored",
     NotFound = "not_found",
     Unauthorized = "unauthorized"
 }
-export type SyncBlockData = {
-    blockInstanceId: string;
+export interface SyncBlockData {
+    blockInstanceId: BlockInstanceId;
     content: Array<ADFEntity>;
     createdAt?: string;
     createdBy?: string;
     isSynced?: boolean;
-    resourceId: string;
+    resourceId: ResourceId;
     sourceDocumentAri?: string;
+    sourceURL?: string;
     updatedAt?: string;
-};
-export type FetchSyncBlockDataResult = SyncBlockData | {
-    resourceId?: string;
-    status: SyncBlockStatus;
-};
-export interface ADFFetchProvider {
-    fetchData: (resourceId: string) => Promise<FetchSyncBlockDataResult>;
-}
-export interface ADFWriteProvider {
-    writeData: (data: SyncBlockData) => Promise<string>;
-}
-export declare abstract class SyncBlockDataProvider extends NodeDataProvider<SyncBlockNode, FetchSyncBlockDataResult> {
-    abstract writeNodesData(nodes: SyncBlockNode[], data: SyncBlockData[]): Promise<Array<string | undefined>>;
-    abstract getSourceId(): string;
-    abstract retrieveSyncBlockSourceUrl(node: SyncBlockNode): Promise<string | undefined>;
 }

package/dist/types/hooks/useFetchSyncBlockData.d.ts

@@ -0,0 +1,4 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { FetchSyncBlockDataResult } from '../providers/types';
+import type { SyncBlockStoreManager } from '../store-manager/syncBlockStoreManager';
+export declare const useFetchSyncBlockData: (manager: SyncBlockStoreManager, syncBlockNode: PMNode) => FetchSyncBlockDataResult | null;

package/dist/types/hooks/useHandleContentChanges.d.ts

@@ -0,0 +1,3 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { SyncBlockStoreManager } from '../store-manager/syncBlockStoreManager';
+export declare const useHandleContentChanges: (manager: SyncBlockStoreManager, syncBlockNode: PMNode) => void;

package/dist/types/index.d.ts

@@ -1,10 +1,13 @@
-export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider, } from './common/syncBlockProvider';
-export { SyncBlockStoreManager, useFetchSyncBlockData, useHandleContentChanges, } from './common/syncBlockStoreManager';
-export type { SyncBlockDataProvider, ADFFetchProvider, ADFWriteProvider, SyncBlockData, SyncBlockNode, FetchSyncBlockDataResult, } from './common/types';
+export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider, } from './providers/syncBlockProvider';
+export { SyncBlockStoreManager } from './store-manager/syncBlockStoreManager';
+export { useFetchSyncBlockData } from './hooks/useFetchSyncBlockData';
+export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export type { SyncBlockData, SyncBlockNode } from './common/types';
+export type { SyncBlockDataProvider, ADFFetchProvider, ADFWriteProvider, FetchSyncBlockDataResult, } from './providers/types';
 export { SyncBlockStatus } from './common/types';
-export { inMemoryFetchProvider, inMemoryWriteProvider } from './providers/inMemory';
+export { inMemoryFetchProvider, inMemoryWriteProvider } from './providers/in-memory/inMemory';
 export { getDefaultSyncBlockSchema } from './common/schema';
-export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders, } from './providers/confluenceContentAPI';
+export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders, } from './providers/confluence/confluenceContentAPI';
 export { getConfluencePageAri } from './utils/ari';
-export { convertSyncBlockPMNodeToSyncBlockNode as convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
+export { convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
 export { rebaseTransaction } from './common/rebase-transaction';

package/dist/{types-ts4.5/providers → types/providers/confluence}/confluenceContentAPI.d.ts

@@ -1,4 +1,5 @@
-import type { ADFFetchProvider, ADFWriteProvider, FetchSyncBlockDataResult, SyncBlockData } from '../common/types';
+import { type SyncBlockData } from '../../common/types';
+import type { ADFFetchProvider, ADFWriteProvider, FetchSyncBlockDataResult } from '../types';
 /**
  * Configuration for Content API providers
  */

package/dist/types/providers/{inMemory.d.ts → in-memory/inMemory.d.ts}

@@ -1,3 +1,3 @@
-import type { ADFFetchProvider, ADFWriteProvider } from '../common/types';
+import type { ADFFetchProvider, ADFWriteProvider } from '../types';
 export declare const inMemoryFetchProvider: ADFFetchProvider;
 export declare const inMemoryWriteProvider: ADFWriteProvider;

package/dist/types/{common → providers}/syncBlockProvider.d.ts

@@ -1,5 +1,6 @@
 import type { JSONNode } from '@atlaskit/editor-json-transformer/types';
-import { SyncBlockDataProvider, type ADFFetchProvider, type ADFWriteProvider, type FetchSyncBlockDataResult, type SyncBlockData, type SyncBlockNode } from './types';
+import type { SyncBlockData, SyncBlockNode } from '../common/types';
+import { SyncBlockDataProvider, type ADFFetchProvider, type ADFWriteProvider, type FetchSyncBlockDataResult } from '../providers/types';
 export declare class SyncBlockProvider extends SyncBlockDataProvider {
     name: string;
     private fetchProvider;

package/dist/types/providers/types.d.ts

@@ -0,0 +1,17 @@
+import { NodeDataProvider } from '@atlaskit/node-data-provider';
+import type { SyncBlockData, ResourceId, SyncBlockStatus, SyncBlockNode } from '../common/types';
+export type FetchSyncBlockDataResult = SyncBlockData | {
+    resourceId?: ResourceId;
+    status: SyncBlockStatus;
+};
+export interface ADFFetchProvider {
+    fetchData: (resourceId: ResourceId) => Promise<FetchSyncBlockDataResult>;
+}
+export interface ADFWriteProvider {
+    writeData: (data: SyncBlockData) => Promise<string>;
+}
+export declare abstract class SyncBlockDataProvider extends NodeDataProvider<SyncBlockNode, FetchSyncBlockDataResult> {
+    abstract writeNodesData(nodes: SyncBlockNode[], data: SyncBlockData[]): Promise<Array<ResourceId | undefined>>;
+    abstract getSourceId(): ResourceId;
+    abstract retrieveSyncBlockSourceUrl(node: SyncBlockNode): Promise<string | undefined>;
+}

package/dist/types/store-manager/referenceSyncBlockStoreManager.d.ts

@@ -0,0 +1,23 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { BlockInstanceId } from '../common/types';
+import type { FetchSyncBlockDataResult, SyncBlockDataProvider } from '../providers/types';
+export declare class ReferenceSyncBlockStoreManager {
+    private dataProvider?;
+    private syncBlockCache;
+    private syncBlockURLRequests;
+    constructor(dataProvider?: SyncBlockDataProvider);
+    /**
+     *
+     * @param localId - The local ID of the sync block to get the source URL for
+     * @param resourceId - The resource ID of the sync block to get the source URL for
+     * Fetches source URl for a sync block and updates sync block data with the source URL asynchronously.
+     */
+    private fetchSyncBlockSourceURL;
+    fetchSyncBlockData(syncBlockNode: PMNode): Promise<FetchSyncBlockDataResult>;
+    /**
+     * Get the URL for a sync block.
+     * @param localId - The local ID of the sync block to get the URL for
+     * @returns
+     */
+    getSyncBlockURL(localId: BlockInstanceId): string | undefined;
+}

package/dist/types/store-manager/sourceSyncBlockStoreManager.d.ts

@@ -0,0 +1,31 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { SyncBlockAttrs, SyncBlockNode } from '../common/types';
+import type { SyncBlockDataProvider } from '../providers/types';
+export type ConfirmationCallback = () => Promise<boolean>;
+export declare class SourceSyncBlockStoreManager {
+    private dataProvider?;
+    private editorView?;
+    private syncBlockCache;
+    private confirmationCallback?;
+    private confirmationTransaction?;
+    constructor(dataProvider?: SyncBlockDataProvider);
+    /**
+     * Add/update a sync block node to/from the local cache
+     * @param syncBlockNode - The sync block node to update
+     */
+    updateSyncBlockData(syncBlockNode: PMNode): void;
+    /**
+     * Save content of bodiedSyncBlock nodes in local cache to backend
+     *
+     * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+     */
+    flushBodiedSyncBlocks(): Promise<boolean>;
+    setEditorView(editorView: EditorView | undefined): void;
+    registerConfirmationCallback(callback: ConfirmationCallback): () => void;
+    requireConfirmationBeforeDelete(): boolean;
+    createSyncBlockNode(): SyncBlockNode;
+    deleteSyncBlocksWithConfirmation(tr: Transaction, syncBlockIds: SyncBlockAttrs[]): Promise<void>;
+    rebaseTransaction(incomingTr: Transaction, state: EditorState): void;
+}

package/dist/types/store-manager/syncBlockStoreManager.d.ts

@@ -0,0 +1,36 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/dist/types/view';
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { BlockInstanceId, SyncBlockAttrs, SyncBlockNode } from '../common/types';
+import type { FetchSyncBlockDataResult, SyncBlockDataProvider } from '../providers/types';
+import { type ConfirmationCallback } from './sourceSyncBlockStoreManager';
+export declare class SyncBlockStoreManager {
+    private referenceSyncBlockStoreManager;
+    private sourceSyncBlockStoreManager;
+    constructor(dataProvider?: SyncBlockDataProvider);
+    fetchSyncBlockData(syncBlockNode: PMNode): Promise<FetchSyncBlockDataResult | undefined>;
+    /**
+     * Add/update a sync block node to/from the local cache
+     * @param syncBlockNode - The sync block node to update
+     */
+    updateSyncBlockData(syncBlockNode: PMNode): void;
+    /**
+     * Save content of bodiedSyncBlock nodes in local cache to backend
+     *
+     * @returns true if saving all nodes successfully, false if fail to save some/all nodes
+     */
+    flushBodiedSyncBlocks(): Promise<boolean>;
+    /**
+     * Get the URL for a sync block.
+     * @param localId - The local ID of the sync block to get the URL for
+     * @returns
+     */
+    getSyncBlockURL(localId: BlockInstanceId): string | undefined;
+    setEditorView(editorView: EditorView | undefined): void;
+    isSourceBlock(node: PMNode): boolean;
+    registerConfirmationCallback(callback: ConfirmationCallback): () => void;
+    requireConfirmationBeforeDelete(): boolean;
+    createSyncBlockNode(): SyncBlockNode;
+    deleteSyncBlocksWithConfirmation(tr: Transaction, syncBlockIds: SyncBlockAttrs[]): Promise<void>;
+    rebaseTransaction(incomingTr: Transaction, state: EditorState): void;
+}

package/dist/types/utils/utils.d.ts

@@ -1,6 +1,5 @@
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-import type { SyncBlockData, SyncBlockNode } from '../common/types';
+import type { SyncBlockData } from '../common/types';
 import type { PAGE_TYPE } from './ari';
-export declare const convertSyncBlockPMNodeToSyncBlockNode: (node: PMNode, includeContent?: boolean) => SyncBlockNode;
 export declare const convertSyncBlockPMNodeToSyncBlockData: (node: PMNode) => SyncBlockData;
 export declare const isBlogPageType: (pageType: PAGE_TYPE) => boolean;

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

@@ -1,42 +1,29 @@
 import type { ADFEntity } from '@atlaskit/adf-utils/types';
 import type { JSONNode } from '@atlaskit/editor-json-transformer/types';
-import { NodeDataProvider } from '@atlaskit/node-data-provider';
+export type BlockInstanceId = string;
+export type ResourceId = string;
 export type SyncBlockAttrs = {
-    localId: string;
-    resourceId: string;
+    localId: BlockInstanceId;
+    resourceId: ResourceId;
 };
-export type SyncBlockNode = {
+export interface SyncBlockNode extends JSONNode {
     attrs: SyncBlockAttrs;
-    content?: Array<JSONNode>;
-    type: 'syncBlock';
-};
+    content?: Array<JSONNode | undefined>;
+    type: 'syncBlock' | 'bodiedSyncBlock';
+}
 export declare enum SyncBlockStatus {
     Errored = "errored",
     NotFound = "not_found",
     Unauthorized = "unauthorized"
 }
-export type SyncBlockData = {
-    blockInstanceId: string;
+export interface SyncBlockData {
+    blockInstanceId: BlockInstanceId;
     content: Array<ADFEntity>;
     createdAt?: string;
     createdBy?: string;
     isSynced?: boolean;
-    resourceId: string;
+    resourceId: ResourceId;
     sourceDocumentAri?: string;
+    sourceURL?: string;
     updatedAt?: string;
-};
-export type FetchSyncBlockDataResult = SyncBlockData | {
-    resourceId?: string;
-    status: SyncBlockStatus;
-};
-export interface ADFFetchProvider {
-    fetchData: (resourceId: string) => Promise<FetchSyncBlockDataResult>;
-}
-export interface ADFWriteProvider {
-    writeData: (data: SyncBlockData) => Promise<string>;
-}
-export declare abstract class SyncBlockDataProvider extends NodeDataProvider<SyncBlockNode, FetchSyncBlockDataResult> {
-    abstract writeNodesData(nodes: SyncBlockNode[], data: SyncBlockData[]): Promise<Array<string | undefined>>;
-    abstract getSourceId(): string;
-    abstract retrieveSyncBlockSourceUrl(node: SyncBlockNode): Promise<string | undefined>;
 }

package/dist/types-ts4.5/hooks/useFetchSyncBlockData.d.ts

@@ -0,0 +1,4 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { FetchSyncBlockDataResult } from '../providers/types';
+import type { SyncBlockStoreManager } from '../store-manager/syncBlockStoreManager';
+export declare const useFetchSyncBlockData: (manager: SyncBlockStoreManager, syncBlockNode: PMNode) => FetchSyncBlockDataResult | null;

package/dist/types-ts4.5/hooks/useHandleContentChanges.d.ts

@@ -0,0 +1,3 @@
+import { type Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { SyncBlockStoreManager } from '../store-manager/syncBlockStoreManager';
+export declare const useHandleContentChanges: (manager: SyncBlockStoreManager, syncBlockNode: PMNode) => void;

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

@@ -1,10 +1,13 @@
-export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider, } from './common/syncBlockProvider';
-export { SyncBlockStoreManager, useFetchSyncBlockData, useHandleContentChanges, } from './common/syncBlockStoreManager';
-export type { SyncBlockDataProvider, ADFFetchProvider, ADFWriteProvider, SyncBlockData, SyncBlockNode, FetchSyncBlockDataResult, } from './common/types';
+export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider, } from './providers/syncBlockProvider';
+export { SyncBlockStoreManager } from './store-manager/syncBlockStoreManager';
+export { useFetchSyncBlockData } from './hooks/useFetchSyncBlockData';
+export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export type { SyncBlockData, SyncBlockNode } from './common/types';
+export type { SyncBlockDataProvider, ADFFetchProvider, ADFWriteProvider, FetchSyncBlockDataResult, } from './providers/types';
 export { SyncBlockStatus } from './common/types';
-export { inMemoryFetchProvider, inMemoryWriteProvider } from './providers/inMemory';
+export { inMemoryFetchProvider, inMemoryWriteProvider } from './providers/in-memory/inMemory';
 export { getDefaultSyncBlockSchema } from './common/schema';
-export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders, } from './providers/confluenceContentAPI';
+export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders, } from './providers/confluence/confluenceContentAPI';
 export { getConfluencePageAri } from './utils/ari';
-export { convertSyncBlockPMNodeToSyncBlockNode as convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
+export { convertSyncBlockPMNodeToSyncBlockData } from './utils/utils';
 export { rebaseTransaction } from './common/rebase-transaction';

package/dist/{types/providers → types-ts4.5/providers/confluence}/confluenceContentAPI.d.ts

@@ -1,4 +1,5 @@
-import type { ADFFetchProvider, ADFWriteProvider, FetchSyncBlockDataResult, SyncBlockData } from '../common/types';
+import { type SyncBlockData } from '../../common/types';
+import type { ADFFetchProvider, ADFWriteProvider, FetchSyncBlockDataResult } from '../types';
 /**
  * Configuration for Content API providers
  */

package/dist/types-ts4.5/providers/{inMemory.d.ts → in-memory/inMemory.d.ts}

@@ -1,3 +1,3 @@
-import type { ADFFetchProvider, ADFWriteProvider } from '../common/types';
+import type { ADFFetchProvider, ADFWriteProvider } from '../types';
 export declare const inMemoryFetchProvider: ADFFetchProvider;
 export declare const inMemoryWriteProvider: ADFWriteProvider;