@atlaskit/editor-synced-block-provider 2.7.4 → 2.9.0

package/dist/es2019/providers/block-service/blockServiceAPI.js

@@ -0,0 +1,148 @@
+import { useMemo } from 'react';
+import { SyncBlockError } from '../../common/types';
+import { blockResourceIdFromSourceAndLocalId, getLocalIdFromResourceId } from '../../utils/ari';
+import { BlockError, createSyncedBlock, deleteSyncedBlock, getSyncedBlockContent, updateSyncedBlock } from '../../utils/blockService';
+import { stringifyError } from '../../utils/errorHandling';
+const mapBlockError = error => {
+  switch (error.status) {
+    case 403:
+      return SyncBlockError.Forbidden;
+    case 404:
+      return SyncBlockError.NotFound;
+  }
+  return SyncBlockError.Errored;
+};
+
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+class BlockServiceADFFetchProvider {
+  // resourceId is the ARI of the block. E.G ari:cloud:blocks:site-123:synced-block/uuid-456
+  // in the content API provider, this was the concatenation of the source document's ARI and the local ID. E.G ari:cloud:confluence:site-123:page/pageId/uuid-456
+  async fetchData(resourceId) {
+    const localId = getLocalIdFromResourceId(resourceId);
+    try {
+      const blockContentResponse = await getSyncedBlockContent({
+        blockAri: resourceId
+      });
+      const value = blockContentResponse.content;
+      if (!value) {
+        return {
+          error: SyncBlockError.NotFound,
+          resourceId
+        };
+      }
+
+      // Parse the synced block content from the response's content
+      const syncedBlockData = JSON.parse(value);
+      return {
+        data: {
+          content: syncedBlockData,
+          resourceId,
+          blockInstanceId: localId
+        },
+        resourceId
+      };
+    } catch (error) {
+      if (error instanceof BlockError) {
+        return {
+          error: mapBlockError(error),
+          resourceId
+        };
+      }
+      return {
+        error: SyncBlockError.Errored,
+        resourceId
+      };
+    }
+  }
+}
+
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+class BlockServiceADFWriteProvider {
+  // it will first try to update and if it can't (404) then it will try to create
+  async writeData(data) {
+    const {
+      resourceId
+    } = data;
+    try {
+      // Try update existing block's content
+      await updateSyncedBlock({
+        blockAri: resourceId,
+        content: JSON.stringify(data.content)
+      });
+      return {
+        resourceId
+      };
+    } catch (error) {
+      if (error instanceof BlockError) {
+        if (error.status === 404) {
+          // Create the block
+          await createSyncedBlock({
+            blockAri: resourceId,
+            blockInstanceId: data.blockInstanceId,
+            sourceAri: resourceId,
+            product: 'confluence-page',
+            content: JSON.stringify(data.content)
+          });
+        } else {
+          return {
+            error: mapBlockError(error),
+            resourceId
+          };
+        }
+      }
+      return {
+        error: stringifyError(error),
+        resourceId
+      };
+    }
+  }
+
+  // soft deletes the source synced block
+  async deleteData(resourceId) {
+    try {
+      await deleteSyncedBlock({
+        blockAri: resourceId
+      });
+      return {
+        resourceId,
+        success: true,
+        error: undefined
+      };
+    } catch (error) {
+      if (error instanceof BlockError) {
+        return {
+          resourceId,
+          success: false,
+          error: mapBlockError(error)
+        };
+      }
+      return {
+        resourceId,
+        success: false,
+        error: stringifyError(error)
+      };
+    }
+  }
+  generateResourceId(sourceId, localId) {
+    return blockResourceIdFromSourceAndLocalId(sourceId, localId);
+  }
+}
+
+/**
+ * Factory function to create both providers with shared configuration
+ */
+const createBlockServiceAPIProviders = () => {
+  const fetchProvider = new BlockServiceADFFetchProvider();
+  const writeProvider = new BlockServiceADFWriteProvider();
+  return {
+    fetchProvider,
+    writeProvider
+  };
+};
+export const useMemoizedBlockServiceAPIProviders = () => {
+  return useMemo(createBlockServiceAPIProviders, []);
+};

package/dist/es2019/providers/confluence/confluenceContentAPI.js

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { useMemo } from 'react';
 import { SyncBlockError } from '../../common/types';
-import { getLocalIdFromAri, getPageIdAndTypeFromAri } from '../../utils/ari';
+import { getLocalIdFromAri, getPageIdAndTypeFromAri, resourceIdFromSourceAndLocalId } from '../../utils/ari';
 import { getContentProperty, createContentProperty, updateContentProperty, deleteContentProperty } from '../../utils/contentProperty';
 import { stringifyError } from '../../utils/errorHandling';
 import { isBlogPageType } from '../../utils/utils';
@@ -227,6 +227,9 @@ class ConfluenceADFWriteProvider {
       error: deleteResult.errors.join()
     };
   }
+  generateResourceId(sourceId, localId) {
+    return resourceIdFromSourceAndLocalId(sourceId, localId);
+  }
 }
 
 /**

package/dist/es2019/providers/syncBlockProvider.js

@@ -99,6 +99,9 @@ export class SyncBlockProvider extends SyncBlockDataProvider {
     }
     return pageARI ? fetchSourceInfo(pageARI, sourceLocalId) : Promise.resolve(undefined);
   }
+  generateResourceId(sourceId, localId) {
+    return this.writeProvider.generateResourceId(sourceId, localId);
+  }
 }
 export const useMemoizedSyncedBlockProvider = (fetchProvider, writeProvider, sourceId) => {
   return useMemo(() => {

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

@@ -2,7 +2,6 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import uuid from 'uuid';
 import { rebaseTransaction } from '../common/rebase-transaction';
-import { resourceIdFromSourceAndLocalId } from '../utils/ari';
 import { convertSyncBlockPMNodeToSyncBlockData, createBodiedSyncBlockNode } from '../utils/utils';
 export class SourceSyncBlockStoreManager {
   constructor(dataProvider) {
@@ -106,12 +105,10 @@ export class SourceSyncBlockStoreManager {
     // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
     const localId = uuid();
     const sourceId = (_this$dataProvider = this.dataProvider) === null || _this$dataProvider === void 0 ? void 0 : _this$dataProvider.getSourceId();
-    if (!sourceId) {
+    if (!this.dataProvider || !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
-    const resourceId = resourceIdFromSourceAndLocalId(sourceId, localId);
+    const resourceId = this.dataProvider.generateResourceId(sourceId, localId);
     return {
       resourceId,
       localId

package/dist/es2019/utils/ari.js

@@ -25,7 +25,37 @@ export const getPageARIFromResourceId = resourceId => {
   }
   throw new Error(`Invalid resourceId: ${resourceId}`);
 };
-export const getContentPropertyAri = (contentPropertyId, cloudId) => `ari:cloud:confluence:${cloudId}:content/${contentPropertyId}`;
 export const resourceIdFromSourceAndLocalId = (sourceId, localId) => {
   return sourceId + '/' + localId;
+};
+
+/**
+ * For the following functions, they are used for the block service API provider.
+ * The resourceId/blockResourceId always refers to the block ARI.
+ */
+
+/**
+ * @param sourceId - the ARI of the document. E.G ari:cloud:confluence:cloudId:page/pageId
+ * @param localId - the localId of the block node. A randomly generated UUID
+ * @returns the block ARI. E.G ari:cloud:blocks:cloudId:synced-block/localId
+ */
+export const blockResourceIdFromSourceAndLocalId = (sourceId, localId) => {
+  const match = sourceId.match(/ari:cloud:confluence:([^:]+):(page|blogpost)\/.*/);
+  if (!(match !== null && match !== void 0 && match[1])) {
+    throw new Error(`Invalid source ARI: ${sourceId}`);
+  }
+  const cloudId = match[1];
+  return `ari:cloud:blocks:${cloudId}:synced-block/${localId}`;
+};
+
+/**
+ * @param ari - the block ARI. E.G ari:cloud:blocks:cloudId:synced-block/localId
+ * @returns the localId of the block node. A randomly generated UUID
+ */
+export const getLocalIdFromResourceId = ari => {
+  const match = ari.match(/ari:cloud:confluence:[^:]+:(page|blogpost)\/\d+\/([a-zA-Z0-9-]+)/);
+  if (match !== null && match !== void 0 && match[2]) {
+    return match[2];
+  }
+  throw new Error(`Invalid page ARI: ${ari}`);
 };

package/dist/es2019/utils/blockService.js

@@ -0,0 +1,71 @@
+const COMMON_HEADERS = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json'
+};
+const BLOCK_SERVICE_API_URL = '/gateway/api/blocks/v1';
+export class BlockError extends Error {
+  constructor(status) {
+    super(`Block error`);
+    this.status = status;
+  }
+}
+export const getSyncedBlockContent = async ({
+  blockAri
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'GET',
+    headers: COMMON_HEADERS
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+  return await response.json();
+};
+export const deleteSyncedBlock = async ({
+  blockAri
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'DELETE',
+    headers: COMMON_HEADERS
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+};
+export const updateSyncedBlock = async ({
+  blockAri,
+  content
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'PUT',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify({
+      content
+    })
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+};
+export const createSyncedBlock = async ({
+  blockAri,
+  blockInstanceId,
+  sourceAri,
+  product,
+  content
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'POST',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify({
+      blockInstanceId,
+      sourceAri,
+      product,
+      content
+    })
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+  return await response.json();
+};

package/dist/esm/index.js

@@ -5,10 +5,11 @@ export { SyncBlockError } from './common/types';
 export { useFetchSyncBlockData } from './hooks/useFetchSyncBlockData';
 export { useFetchSyncBlockTitle } from './hooks/useFetchSyncBlockTitle';
 export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export { useMemoizedBlockServiceAPIProviders } from './providers/block-service/blockServiceAPI';
 export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders } from './providers/confluence/confluenceContentAPI';
 export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
 export { ReferenceSyncBlockStoreManager } from './store-manager/referenceSyncBlockStoreManager';
 export { SyncBlockStoreManager } from './store-manager/syncBlockStoreManager';
-export { getConfluencePageAri, getPageIdAndTypeFromAri } from './utils/ari';
+export { blockResourceIdFromSourceAndLocalId, getConfluencePageAri, getLocalIdFromAri, getLocalIdFromResourceId, getPageARIFromResourceId, getPageIdAndTypeFromAri, resourceIdFromSourceAndLocalId } from './utils/ari';
 export { createSyncBlockNode, convertSyncBlockPMNodeToSyncBlockData, convertSyncBlockJSONNodeToSyncBlockNode } from './utils/utils';
 export { resolveSyncBlockInstance } from './utils/resolveSyncBlockInstance';

package/dist/esm/providers/block-service/blockServiceAPI.js

@@ -0,0 +1,231 @@
+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 { useMemo } from 'react';
+import { SyncBlockError } from '../../common/types';
+import { blockResourceIdFromSourceAndLocalId, getLocalIdFromResourceId } from '../../utils/ari';
+import { BlockError, createSyncedBlock, deleteSyncedBlock, getSyncedBlockContent, updateSyncedBlock } from '../../utils/blockService';
+import { stringifyError } from '../../utils/errorHandling';
+var mapBlockError = function mapBlockError(error) {
+  switch (error.status) {
+    case 403:
+      return SyncBlockError.Forbidden;
+    case 404:
+      return SyncBlockError.NotFound;
+  }
+  return SyncBlockError.Errored;
+};
+
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
+  function BlockServiceADFFetchProvider() {
+    _classCallCheck(this, BlockServiceADFFetchProvider);
+  }
+  return _createClass(BlockServiceADFFetchProvider, [{
+    key: "fetchData",
+    value: // resourceId is the ARI of the block. E.G ari:cloud:blocks:site-123:synced-block/uuid-456
+    // in the content API provider, this was the concatenation of the source document's ARI and the local ID. E.G ari:cloud:confluence:site-123:page/pageId/uuid-456
+    function () {
+      var _fetchData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(resourceId) {
+        var localId, blockContentResponse, value, syncedBlockData;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              localId = getLocalIdFromResourceId(resourceId);
+              _context.prev = 1;
+              _context.next = 4;
+              return getSyncedBlockContent({
+                blockAri: resourceId
+              });
+            case 4:
+              blockContentResponse = _context.sent;
+              value = blockContentResponse.content;
+              if (value) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", {
+                error: SyncBlockError.NotFound,
+                resourceId: resourceId
+              });
+            case 8:
+              // Parse the synced block content from the response's content
+              syncedBlockData = JSON.parse(value);
+              return _context.abrupt("return", {
+                data: {
+                  content: syncedBlockData,
+                  resourceId: resourceId,
+                  blockInstanceId: localId
+                },
+                resourceId: resourceId
+              });
+            case 12:
+              _context.prev = 12;
+              _context.t0 = _context["catch"](1);
+              if (!(_context.t0 instanceof BlockError)) {
+                _context.next = 16;
+                break;
+              }
+              return _context.abrupt("return", {
+                error: mapBlockError(_context.t0),
+                resourceId: resourceId
+              });
+            case 16:
+              return _context.abrupt("return", {
+                error: SyncBlockError.Errored,
+                resourceId: resourceId
+              });
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 12]]);
+      }));
+      function fetchData(_x) {
+        return _fetchData.apply(this, arguments);
+      }
+      return fetchData;
+    }()
+  }]);
+}();
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+var BlockServiceADFWriteProvider = /*#__PURE__*/function () {
+  function BlockServiceADFWriteProvider() {
+    _classCallCheck(this, BlockServiceADFWriteProvider);
+  }
+  return _createClass(BlockServiceADFWriteProvider, [{
+    key: "writeData",
+    value: // it will first try to update and if it can't (404) then it will try to create
+    function () {
+      var _writeData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(data) {
+        var resourceId;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              resourceId = data.resourceId;
+              _context2.prev = 1;
+              _context2.next = 4;
+              return updateSyncedBlock({
+                blockAri: resourceId,
+                content: JSON.stringify(data.content)
+              });
+            case 4:
+              return _context2.abrupt("return", {
+                resourceId: resourceId
+              });
+            case 7:
+              _context2.prev = 7;
+              _context2.t0 = _context2["catch"](1);
+              if (!(_context2.t0 instanceof BlockError)) {
+                _context2.next = 16;
+                break;
+              }
+              if (!(_context2.t0.status === 404)) {
+                _context2.next = 15;
+                break;
+              }
+              _context2.next = 13;
+              return createSyncedBlock({
+                blockAri: resourceId,
+                blockInstanceId: data.blockInstanceId,
+                sourceAri: resourceId,
+                product: 'confluence-page',
+                content: JSON.stringify(data.content)
+              });
+            case 13:
+              _context2.next = 16;
+              break;
+            case 15:
+              return _context2.abrupt("return", {
+                error: mapBlockError(_context2.t0),
+                resourceId: resourceId
+              });
+            case 16:
+              return _context2.abrupt("return", {
+                error: stringifyError(_context2.t0),
+                resourceId: resourceId
+              });
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[1, 7]]);
+      }));
+      function writeData(_x2) {
+        return _writeData.apply(this, arguments);
+      }
+      return writeData;
+    }() // soft deletes the source synced block
+  }, {
+    key: "deleteData",
+    value: function () {
+      var _deleteData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(resourceId) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return deleteSyncedBlock({
+                blockAri: resourceId
+              });
+            case 3:
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: true,
+                error: undefined
+              });
+            case 6:
+              _context3.prev = 6;
+              _context3.t0 = _context3["catch"](0);
+              if (!(_context3.t0 instanceof BlockError)) {
+                _context3.next = 10;
+                break;
+              }
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: false,
+                error: mapBlockError(_context3.t0)
+              });
+            case 10:
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: false,
+                error: stringifyError(_context3.t0)
+              });
+            case 11:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, null, [[0, 6]]);
+      }));
+      function deleteData(_x3) {
+        return _deleteData.apply(this, arguments);
+      }
+      return deleteData;
+    }()
+  }, {
+    key: "generateResourceId",
+    value: function generateResourceId(sourceId, localId) {
+      return blockResourceIdFromSourceAndLocalId(sourceId, localId);
+    }
+  }]);
+}();
+/**
+ * Factory function to create both providers with shared configuration
+ */
+var createBlockServiceAPIProviders = function createBlockServiceAPIProviders() {
+  var fetchProvider = new BlockServiceADFFetchProvider();
+  var writeProvider = new BlockServiceADFWriteProvider();
+  return {
+    fetchProvider: fetchProvider,
+    writeProvider: writeProvider
+  };
+};
+export var useMemoizedBlockServiceAPIProviders = function useMemoizedBlockServiceAPIProviders() {
+  return useMemo(createBlockServiceAPIProviders, []);
+};

package/dist/esm/providers/confluence/confluenceContentAPI.js

@@ -6,7 +6,7 @@ import _typeof from "@babel/runtime/helpers/typeof";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { useMemo } from 'react';
 import { SyncBlockError } from '../../common/types';
-import { getLocalIdFromAri, getPageIdAndTypeFromAri } from '../../utils/ari';
+import { getLocalIdFromAri, getPageIdAndTypeFromAri, resourceIdFromSourceAndLocalId } from '../../utils/ari';
 import { getContentProperty, createContentProperty, updateContentProperty, deleteContentProperty } from '../../utils/contentProperty';
 import { stringifyError } from '../../utils/errorHandling';
 import { isBlogPageType } from '../../utils/utils';
@@ -337,6 +337,11 @@ var ConfluenceADFWriteProvider = /*#__PURE__*/function () {
       }
       return deleteData;
     }()
+  }, {
+    key: "generateResourceId",
+    value: function generateResourceId(sourceId, localId) {
+      return resourceIdFromSourceAndLocalId(sourceId, localId);
+    }
   }]);
 }();
 /**

package/dist/esm/providers/syncBlockProvider.js

@@ -170,6 +170,11 @@ export var SyncBlockProvider = /*#__PURE__*/function (_SyncBlockDataProvide) {
       }
       return pageARI ? fetchSourceInfo(pageARI, sourceLocalId) : Promise.resolve(undefined);
     }
+  }, {
+    key: "generateResourceId",
+    value: function generateResourceId(sourceId, localId) {
+      return this.writeProvider.generateResourceId(sourceId, localId);
+    }
   }]);
 }(SyncBlockDataProvider);
 export var useMemoizedSyncedBlockProvider = function useMemoizedSyncedBlockProvider(fetchProvider, writeProvider, sourceId) {

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

@@ -6,7 +6,6 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import uuid from 'uuid';
 import { rebaseTransaction as _rebaseTransaction } from '../common/rebase-transaction';
-import { resourceIdFromSourceAndLocalId } from '../utils/ari';
 import { convertSyncBlockPMNodeToSyncBlockData, createBodiedSyncBlockNode as _createBodiedSyncBlockNode } from '../utils/utils';
 export var SourceSyncBlockStoreManager = /*#__PURE__*/function () {
   function SourceSyncBlockStoreManager(dataProvider) {
@@ -158,12 +157,10 @@ export var SourceSyncBlockStoreManager = /*#__PURE__*/function () {
       // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
       var localId = uuid();
       var sourceId = (_this$dataProvider = this.dataProvider) === null || _this$dataProvider === void 0 ? void 0 : _this$dataProvider.getSourceId();
-      if (!sourceId) {
+      if (!this.dataProvider || !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, localId);
+      var resourceId = this.dataProvider.generateResourceId(sourceId, localId);
       return {
         resourceId: resourceId,
         localId: localId

package/dist/esm/utils/ari.js

@@ -28,9 +28,37 @@ export var getPageARIFromResourceId = function getPageARIFromResourceId(resource
   }
   throw new Error("Invalid resourceId: ".concat(resourceId));
 };
-export var getContentPropertyAri = function getContentPropertyAri(contentPropertyId, cloudId) {
-  return "ari:cloud:confluence:".concat(cloudId, ":content/").concat(contentPropertyId);
-};
 export var resourceIdFromSourceAndLocalId = function resourceIdFromSourceAndLocalId(sourceId, localId) {
   return sourceId + '/' + localId;
+};
+
+/**
+ * For the following functions, they are used for the block service API provider.
+ * The resourceId/blockResourceId always refers to the block ARI.
+ */
+
+/**
+ * @param sourceId - the ARI of the document. E.G ari:cloud:confluence:cloudId:page/pageId
+ * @param localId - the localId of the block node. A randomly generated UUID
+ * @returns the block ARI. E.G ari:cloud:blocks:cloudId:synced-block/localId
+ */
+export var blockResourceIdFromSourceAndLocalId = function blockResourceIdFromSourceAndLocalId(sourceId, localId) {
+  var match = sourceId.match(/ari:cloud:confluence:([^:]+):(page|blogpost)\/.*/);
+  if (!(match !== null && match !== void 0 && match[1])) {
+    throw new Error("Invalid source ARI: ".concat(sourceId));
+  }
+  var cloudId = match[1];
+  return "ari:cloud:blocks:".concat(cloudId, ":synced-block/").concat(localId);
+};
+
+/**
+ * @param ari - the block ARI. E.G ari:cloud:blocks:cloudId:synced-block/localId
+ * @returns the localId of the block node. A randomly generated UUID
+ */
+export var getLocalIdFromResourceId = function getLocalIdFromResourceId(ari) {
+  var match = ari.match(/ari:cloud:confluence:[^:]+:(page|blogpost)\/\d+\/([a-zA-Z0-9-]+)/);
+  if (match !== null && match !== void 0 && match[2]) {
+    return match[2];
+  }
+  throw new Error("Invalid page ARI: ".concat(ari));
 };