@atlaskit/editor-synced-block-provider 4.1.0 → 4.1.2

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

@@ -1,7 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import isEqual from 'lodash/isEqual';
 import { logException } from '@atlaskit/editor-common/monitoring';
-import { fg } from '@atlaskit/platform-feature-flags';
 import { SyncBlockError } from '../common/types';
 import { updateErrorPayload, createErrorPayload, deleteErrorPayload, updateCacheErrorPayload, getSourceInfoErrorPayload, updateSuccessPayload, createSuccessPayload, deleteSuccessPayload, fetchReferencesErrorPayload } from '../utils/errorHandling';
 import { getCreateSourceExperience, getDeleteSourceExperience, getSaveSourceExperience, getFetchSourceInfoExperience } from '../utils/experienceTracking';
@@ -52,11 +51,9 @@ export class SourceSyncBlockStoreManager {
         throw new Error('Local ID or resource ID is not set');
       }
       const syncBlockData = convertSyncBlockPMNodeToSyncBlockData(syncBlockNode);
-      if (fg('platform_synced_block_patch_5')) {
-        const cachedBlock = this.syncBlockCache.get(resourceId);
-        if (cachedBlock && !isEqual(syncBlockData.content, cachedBlock.content)) {
-          this.hasReceivedContentChange = true;
-        }
+      const cachedBlock = this.syncBlockCache.get(resourceId);
+      if (cachedBlock && !isEqual(syncBlockData.content, cachedBlock.content)) {
+        this.hasReceivedContentChange = true;
       }
       this.syncBlockCache.set(resourceId, {
         ...syncBlockData,

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

@@ -1,20 +1,35 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { logException } from '@atlaskit/editor-common/monitoring';
-import { fg } from '@atlaskit/platform-feature-flags';
 import { fetchErrorPayload, fetchSuccessPayload } from '../utils/errorHandling';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 /**
  * Manages the lifecycle of GraphQL WebSocket subscriptions for sync block
- * real-time updates, and provides a listener API so React components can
- * react when the set of subscribed resource IDs changes.
+ * real-time updates, owns the subscriptions and titleSubscriptions maps,
+ * and provides a listener API so React components can react when the set
+ * of subscribed resource IDs changes.
  */
 export class SyncBlockSubscriptionManager {
   constructor(deps) {
+    _defineProperty(this, "subscriptions", new Map());
+    _defineProperty(this, "titleSubscriptions", new Map());
     _defineProperty(this, "graphqlSubscriptions", new Map());
     _defineProperty(this, "subscriptionChangeListeners", new Set());
     _defineProperty(this, "useRealTimeSubscriptions", false);
+    // Track pending cache deletions to handle block moves (unmount/remount)
+    // When a block is moved, the old component unmounts before the new one mounts,
+    // causing the cache to be deleted prematurely. We delay deletion to allow
+    // the new component to subscribe and cancel the pending deletion.
+    _defineProperty(this, "pendingCacheDeletions", new Map());
     this.deps = deps;
   }
+
+  /**
+   * Returns the subscriptions map. Used by external consumers (e.g. batch fetcher, flush)
+   * that need to read the current subscription state.
+   */
+  getSubscriptions() {
+    return this.subscriptions;
+  }
   setRealTimeSubscriptionsEnabled(enabled) {
     if (this.useRealTimeSubscriptions === enabled) {
       return;
@@ -30,7 +45,7 @@ export class SyncBlockSubscriptionManager {
     return this.useRealTimeSubscriptions;
   }
   getSubscribedResourceIds() {
-    return Array.from(this.deps.getSubscriptions().keys());
+    return Array.from(this.subscriptions.keys());
   }
   onSubscriptionsChanged(listener) {
     this.subscriptionChangeListeners.add(listener);
@@ -62,6 +77,133 @@ export class SyncBlockSubscriptionManager {
       this.deps.fetchSyncBlockSourceInfo(resolved.resourceId);
     }
   }
+  subscribeToSyncBlock(resourceId, localId, callback) {
+    // Cancel any pending cache deletion for this resourceId.
+    // This handles the case where a block is moved - the old component unmounts
+    // (scheduling deletion) but the new component mounts and subscribes before
+    // the deletion timeout fires.
+    const pendingDeletion = this.pendingCacheDeletions.get(resourceId);
+    if (pendingDeletion) {
+      clearTimeout(pendingDeletion);
+      this.pendingCacheDeletions.delete(resourceId);
+    }
+
+    // add to subscriptions map
+    const resourceSubscriptions = this.subscriptions.get(resourceId) || {};
+    const isNewResourceSubscription = Object.keys(resourceSubscriptions).length === 0;
+    this.subscriptions.set(resourceId, {
+      ...resourceSubscriptions,
+      [localId]: callback
+    });
+
+    // New subscription means new reference synced block is added to the document
+    this.deps.markCacheDirty();
+
+    // Notify listeners if this is a new resource subscription
+    if (isNewResourceSubscription) {
+      this.notifySubscriptionChangeListeners();
+    }
+    const cachedData = this.deps.getFromCache(resourceId);
+    if (cachedData) {
+      callback(cachedData);
+    } else {
+      this.deps.debouncedBatchedFetchSyncBlocks(resourceId);
+    }
+
+    // Set up GraphQL subscription if real-time subscriptions are enabled
+    if (this.shouldUseRealTime()) {
+      this.setupSubscription(resourceId);
+    }
+    return () => {
+      const resourceSubscriptions = this.subscriptions.get(resourceId);
+      if (resourceSubscriptions) {
+        // Unsubscription means a reference synced block is removed from the document
+        this.deps.markCacheDirty();
+        delete resourceSubscriptions[localId];
+        if (Object.keys(resourceSubscriptions).length === 0) {
+          this.subscriptions.delete(resourceId);
+
+          // Clean up GraphQL subscription when no more local subscribers
+          this.cleanupSubscription(resourceId);
+
+          // Notify listeners that subscription was removed
+          this.notifySubscriptionChangeListeners();
+
+          // Delay cache deletion to handle block moves (unmount/remount).
+          // When a block is moved, the old component unmounts before the new one mounts.
+          // By delaying deletion, we give the new component time to subscribe and
+          // cancel this pending deletion, preserving the cached data.
+          // TODO: EDITOR-4152 - Rework this logic
+          const deletionTimeout = setTimeout(() => {
+            // Only delete if still no subscribers (wasn't re-subscribed)
+            if (!this.subscriptions.has(resourceId)) {
+              this.deps.deleteFromCache(resourceId);
+            }
+            this.pendingCacheDeletions.delete(resourceId);
+          }, 1000);
+          this.pendingCacheDeletions.set(resourceId, deletionTimeout);
+        } else {
+          this.subscriptions.set(resourceId, resourceSubscriptions);
+        }
+      }
+    };
+  }
+  subscribeToSourceTitle(node, callback) {
+    var _cachedData$data;
+    // check node is a sync block, as we only support sync block subscriptions
+    if (node.type.name !== 'syncBlock') {
+      return () => {};
+    }
+    const {
+      resourceId,
+      localId
+    } = node.attrs;
+    if (!localId || !resourceId) {
+      return () => {};
+    }
+    const cachedData = this.deps.getFromCache(resourceId);
+    if (cachedData !== null && cachedData !== void 0 && (_cachedData$data = cachedData.data) !== null && _cachedData$data !== void 0 && _cachedData$data.sourceTitle) {
+      callback(cachedData.data.sourceTitle);
+    }
+
+    // add to subscriptions map
+    const resourceSubscriptions = this.titleSubscriptions.get(resourceId) || {};
+    this.titleSubscriptions.set(resourceId, {
+      ...resourceSubscriptions,
+      [localId]: callback
+    });
+    return () => {
+      const resourceSubscriptions = this.titleSubscriptions.get(resourceId);
+      if (resourceSubscriptions) {
+        delete resourceSubscriptions[localId];
+        if (Object.keys(resourceSubscriptions).length === 0) {
+          this.titleSubscriptions.delete(resourceId);
+        } else {
+          this.titleSubscriptions.set(resourceId, resourceSubscriptions);
+        }
+      }
+    };
+  }
+  updateSourceTitleSubscriptions(resourceId, title) {
+    const callbacks = this.titleSubscriptions.get(resourceId);
+    if (callbacks) {
+      Object.values(callbacks).forEach(callback => {
+        callback(title);
+      });
+    }
+  }
+
+  /**
+   * Notifies all subscription callbacks for a given resource ID with the provided sync block instance.
+   */
+  notifySubscriptionCallbacks(resourceId, syncBlock) {
+    const callbacks = this.subscriptions.get(resourceId);
+    if (callbacks) {
+      Object.values(callbacks).forEach(callback => {
+        callback(syncBlock);
+      });
+    }
+  }
   setupSubscription(resourceId) {
     if (this.graphqlSubscriptions.has(resourceId)) {
       return;
@@ -91,7 +233,7 @@ export class SyncBlockSubscriptionManager {
     }
   }
   setupSubscriptionsForAllBlocks() {
-    for (const resourceId of this.deps.getSubscriptions().keys()) {
+    for (const resourceId of this.subscriptions.keys()) {
       this.setupSubscription(resourceId);
     }
   }
@@ -103,24 +245,29 @@ export class SyncBlockSubscriptionManager {
   }
   destroy() {
     this.cleanupAll();
+    this.subscriptions.clear();
+    this.titleSubscriptions.clear();
     this.subscriptionChangeListeners.clear();
     this.useRealTimeSubscriptions = false;
+
+    // Clear any pending cache deletions
+    for (const timeout of this.pendingCacheDeletions.values()) {
+      clearTimeout(timeout);
+    }
+    this.pendingCacheDeletions.clear();
   }
   shouldUseRealTime() {
     return this.useRealTimeSubscriptions;
   }
   handleGraphQLUpdate(syncBlockInstance) {
     if (!syncBlockInstance.resourceId) {
-      if (fg('platform_synced_block_patch_5')) {
-        return;
-      }
-      throw new Error('Sync block instance provided to graphql subscription update missing resource id');
+      return;
     }
     const existing = this.deps.getFromCache(syncBlockInstance.resourceId);
     const resolved = existing ? resolveSyncBlockInstance(existing, syncBlockInstance) : syncBlockInstance;
     this.deps.updateCache(resolved);
     if (!syncBlockInstance.error) {
-      const callbacks = this.deps.getSubscriptions().get(syncBlockInstance.resourceId);
+      const callbacks = this.subscriptions.get(syncBlockInstance.resourceId);
       const localIds = callbacks ? Object.keys(callbacks) : [];
       localIds.forEach(localId => {
         var _this$deps$getFireAna3, _syncBlockInstance$da;