@atlaskit/editor-plugin-block-controls 20.0.2 → 20.1.0

package/dist/es2019/pm-plugins/utils/sparse-surface-candidates.js

@@ -0,0 +1,305 @@
+import { BLOCK_CONTROL_UI_CONTEXT } from '@atlaskit/editor-common/block-controls/block-control-ui-context';
+import { createSurfaceContext } from '@atlaskit/editor-ui-control-model/create-surface-context';
+import { willComponentRender } from '@atlaskit/editor-ui-control-model/surface-renderer';
+import { createBlockControlsSurfaceContextForPosition } from '../../ui/block-controls-surface-context';
+import { hasSurfaceControls } from '../../ui/utils/has-surface-controls';
+
+/**
+ * Viewport positions are post-transaction positions supplied by the DOM observer. The reducer
+ * never needs to inspect DOM or search document IDs for viewport discovery.
+ */
+
+const NO_ACTIVE = 'none';
+const EMPTY_CANDIDATES = new Map();
+const EMPTY_POSITIONS = [];
+const EMPTY_PROTECTED_POSITIONS = [];
+export const emptySparseSurfaceCandidateState = {
+  activeRevision: NO_ACTIVE,
+  candidates: EMPTY_CANDIDATES,
+  positions: EMPTY_POSITIONS,
+  protectedPositions: EMPTY_PROTECTED_POSITIONS,
+  visiblePositions: EMPTY_POSITIONS
+};
+const getActiveRevision = activeNode => {
+  var _activeNode$rootPos, _activeNode$rootNodeT;
+  return activeNode ? [activeNode.pos, activeNode.nodeType, (_activeNode$rootPos = activeNode.rootPos) !== null && _activeNode$rootPos !== void 0 ? _activeNode$rootPos : activeNode.pos, (_activeNode$rootNodeT = activeNode.rootNodeType) !== null && _activeNode$rootNodeT !== void 0 ? _activeNode$rootNodeT : ''].join(':') : NO_ACTIVE;
+};
+const isInRange = (position, range) => position >= range.from && position <= range.to;
+const normalizeRange = (range, contentSize) => ({
+  from: Math.max(0, Math.min(contentSize, Math.min(range.from, range.to))),
+  to: Math.max(0, Math.min(contentSize, Math.max(range.from, range.to)))
+});
+const getSurfaces = resolvedSurfaces => resolvedSurfaces.flatMap(({
+  childrenMap,
+  components,
+  root
+}) => root && hasSurfaceControls(components) ? [{
+  childrenMap,
+  root
+}] : []);
+const getNodeId = node => {
+  var _node$attrs;
+  const localId = (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId;
+  return typeof localId === 'string' ? localId : undefined;
+};
+const sameCandidate = (first, second) => (first === null || first === void 0 ? void 0 : first.id) === (second === null || second === void 0 ? void 0 : second.id) && (first === null || first === void 0 ? void 0 : first.contextRevision) === (second === null || second === void 0 ? void 0 : second.contextRevision) && (first === null || first === void 0 ? void 0 : first.isPersistent) === (second === null || second === void 0 ? void 0 : second.isPersistent) && (first === null || first === void 0 ? void 0 : first.nodeRef) === (second === null || second === void 0 ? void 0 : second.nodeRef) && (first === null || first === void 0 ? void 0 : first.nodeType) === (second === null || second === void 0 ? void 0 : second.nodeType) && (first === null || first === void 0 ? void 0 : first.nodeSize) === (second === null || second === void 0 ? void 0 : second.nodeSize) && (first === null || first === void 0 ? void 0 : first.pos) === (second === null || second === void 0 ? void 0 : second.pos) && (first === null || first === void 0 ? void 0 : first.renders) === (second === null || second === void 0 ? void 0 : second.renders);
+const sameCandidateMap = (first, second) => {
+  if (first.size !== second.size) {
+    return false;
+  }
+  for (const [position, candidate] of first) {
+    if (!sameCandidate(candidate, second.get(position))) {
+      return false;
+    }
+  }
+  return true;
+};
+const samePositions = (first, second) => first.length === second.length && first.every((position, index) => position === second[index]);
+const normalizePositions = positions => Array.from(new Set(positions)).sort((first, second) => first - second);
+const mapPositions = (positions, tr) => normalizePositions(positions.map(position => tr.docChanged ? tr.mapping.mapResult(position, 1) : {
+  deleted: false,
+  pos: position
+}).filter(result => !result.deleted).map(result => result.pos));
+const createSurfaceContextAtPosition = (state, position, activeNode) => {
+  const blockControlsContext = createBlockControlsSurfaceContextForPosition(state, position, activeNode);
+  return blockControlsContext ? createSurfaceContext(BLOCK_CONTROL_UI_CONTEXT, blockControlsContext) : undefined;
+};
+const willAnySurfaceRenderAt = (surfaces, state, position, activeNode) => {
+  const surfaceContext = createSurfaceContextAtPosition(state, position, activeNode);
+  return surfaces.some(({
+    childrenMap,
+    root
+  }) => willComponentRender(root, childrenMap, surfaceContext));
+};
+const addCandidateAt = ({
+  candidates,
+  position,
+  state,
+  surfaces,
+  activeNode
+}) => {
+  const node = state.doc.nodeAt(position);
+  if (!(node !== null && node !== void 0 && node.isBlock)) {
+    candidates.delete(position);
+    return;
+  }
+  const isPersistent = willAnySurfaceRenderAt(surfaces, state, position, undefined);
+  const renders = isPersistent || activeNode !== undefined && willAnySurfaceRenderAt(surfaces, state, position, activeNode);
+  candidates.set(position, {
+    contextRevision: getActiveRevision(activeNode),
+    id: getNodeId(node),
+    isPersistent,
+    nodeRef: node,
+    nodeType: node.type.name,
+    nodeSize: node.nodeSize,
+    renders,
+    pos: position
+  });
+};
+const isInvalidated = (candidate, position, invalidation, changedRange) => {
+  var _invalidation$ids, _invalidation$positio, _invalidation$ranges;
+  if (invalidation !== null && invalidation !== void 0 && invalidation.all) {
+    return true;
+  }
+  if (invalidation !== null && invalidation !== void 0 && (_invalidation$ids = invalidation.ids) !== null && _invalidation$ids !== void 0 && _invalidation$ids.some(id => id === candidate.id)) {
+    return true;
+  }
+  if (invalidation !== null && invalidation !== void 0 && (_invalidation$positio = invalidation.positions) !== null && _invalidation$positio !== void 0 && _invalidation$positio.includes(position)) {
+    return true;
+  }
+  return Boolean(changedRange && isInRange(position, changedRange) || (invalidation === null || invalidation === void 0 ? void 0 : (_invalidation$ranges = invalidation.ranges) === null || _invalidation$ranges === void 0 ? void 0 : _invalidation$ranges.some(range => isInRange(position, range))));
+};
+const getPositions = candidates => Array.from(candidates.values()).filter(candidate => candidate.renders).map(candidate => candidate.pos).sort((first, second) => first - second);
+const mapCandidates = (state, tr, retain) => {
+  const mapped = new Map();
+  for (const candidate of state.candidates.values()) {
+    const result = tr.docChanged ? tr.mapping.mapResult(candidate.pos, 1) : {
+      deleted: false,
+      pos: candidate.pos
+    };
+    if (!result.deleted && retain(result.pos, candidate)) {
+      mapped.set(result.pos, result.pos === candidate.pos ? candidate : {
+        ...candidate,
+        pos: result.pos
+      });
+    }
+  }
+  return mapped;
+};
+/** Map cache state during PM apply. This phase never calls isHidden or scans doc. */
+export const mapSparseSurfaceCandidates = ({
+  newState,
+  previousState,
+  tr
+}) => {
+  if (!tr.docChanged) {
+    return previousState;
+  }
+  const candidates = new Map();
+  for (const candidate of previousState.candidates.values()) {
+    const result = tr.mapping.mapResult(candidate.pos, 1);
+    if (!result.deleted) {
+      candidates.set(result.pos, result.pos === candidate.pos ? candidate : {
+        ...candidate,
+        pos: result.pos
+      });
+    }
+  }
+  const protectedPositions = normalizePositions(previousState.protectedPositions.map(position => tr.mapping.mapResult(position, 1)).filter(result => !result.deleted).map(result => result.pos));
+  const visiblePositions = mapPositions(previousState.visiblePositions, tr);
+  const positions = getPositions(candidates);
+  const candidatesUnchanged = sameCandidateMap(previousState.candidates, candidates);
+  const positionsUnchanged = samePositions(previousState.positions, positions);
+  const protectedUnchanged = samePositions(previousState.protectedPositions, protectedPositions);
+  if (candidatesUnchanged && positionsUnchanged && protectedUnchanged && samePositions(previousState.visiblePositions, visiblePositions)) {
+    return previousState;
+  }
+  return {
+    ...previousState,
+    candidates: candidatesUnchanged ? previousState.candidates : candidates,
+    positions: positionsUnchanged ? previousState.positions : positions,
+    protectedPositions: protectedUnchanged ? previousState.protectedPositions : protectedPositions,
+    visiblePositions
+  };
+};
+/**
+ * Reconcile after view state is current. Predicate work stays bounded to cache,
+ * exact visible positions, explicit ranges, and protected active/menu positions.
+ */
+export const reconcileSparseSurfaceCandidates = ({
+  activeNodesByPosition,
+  activeNode,
+  changedRange,
+  documentChanged = false,
+  invalidation,
+  newState,
+  protectedPositions,
+  resolvedSurfaces,
+  state,
+  visiblePositions
+}) => reduceSparseSurfaceCandidates({
+  activeNode,
+  meta: {
+    activeNodesByPosition,
+    changedRange,
+    documentChanged,
+    invalidation,
+    protectedPositions,
+    visiblePositions
+  },
+  newState,
+  previousState: state,
+  resolvedSurfaces,
+  tr: newState.tr
+});
+
+/**
+ * Update sparse candidates. Viewport and invalidation metadata are the only
+ * discovery inputs; active changes re-evaluate retained cache, never document.
+ */
+export const reduceSparseSurfaceCandidates = ({
+  activeNode,
+  meta,
+  newState,
+  previousState,
+  resolvedSurfaces,
+  tr
+}) => {
+  var _meta$visiblePosition, _meta$protectedPositi, _meta$documentChanged, _invalidation$positio2;
+  const activeRevision = getActiveRevision(activeNode);
+  const activeChanged = activeRevision !== previousState.activeRevision;
+  const hasVisiblePositionsUpdate = Boolean(meta && Object.prototype.hasOwnProperty.call(meta, 'visiblePositions'));
+  const visiblePositions = hasVisiblePositionsUpdate ? normalizePositions((_meta$visiblePosition = meta === null || meta === void 0 ? void 0 : meta.visiblePositions) !== null && _meta$visiblePosition !== void 0 ? _meta$visiblePosition : EMPTY_POSITIONS) : tr.docChanged ? mapPositions(previousState.visiblePositions, tr) : previousState.visiblePositions;
+  const visiblePositionsChanged = !samePositions(visiblePositions, previousState.visiblePositions);
+  const requestedProtectedPositions = normalizePositions((_meta$protectedPositi = meta === null || meta === void 0 ? void 0 : meta.protectedPositions) !== null && _meta$protectedPositi !== void 0 ? _meta$protectedPositi : previousState.protectedPositions);
+  const protectedPositions = samePositions(previousState.protectedPositions, requestedProtectedPositions) ? previousState.protectedPositions : requestedProtectedPositions;
+  const protectedSet = new Set(protectedPositions);
+  if (activeNode) {
+    var _activeNode$rootPos2;
+    protectedSet.add(activeNode.pos);
+    protectedSet.add((_activeNode$rootPos2 = activeNode.rootPos) !== null && _activeNode$rootPos2 !== void 0 ? _activeNode$rootPos2 : activeNode.pos);
+  }
+  const visibleSet = new Set(visiblePositions);
+  const retain = (position, candidate) => ((candidate === null || candidate === void 0 ? void 0 : candidate.isPersistent) || protectedSet.has(position) || visibleSet.has(position)) && position >= 0 && position <= newState.doc.content.size;
+  const surfaces = getSurfaces(resolvedSurfaces);
+  const activeNodeAt = position => {
+    var _ref, _meta$activeNodesByPo, _meta$activeNodesByPo2;
+    return (_ref = (_meta$activeNodesByPo = meta === null || meta === void 0 ? void 0 : (_meta$activeNodesByPo2 = meta.activeNodesByPosition) === null || _meta$activeNodesByPo2 === void 0 ? void 0 : _meta$activeNodesByPo2.get(position)) !== null && _meta$activeNodesByPo !== void 0 ? _meta$activeNodesByPo : activeNode) !== null && _ref !== void 0 ? _ref : undefined;
+  };
+  const changedRange = meta !== null && meta !== void 0 && meta.changedRange ? normalizeRange(meta.changedRange, newState.doc.content.size) : undefined;
+  const invalidation = meta === null || meta === void 0 ? void 0 : meta.invalidation;
+  const documentChanged = (_meta$documentChanged = meta === null || meta === void 0 ? void 0 : meta.documentChanged) !== null && _meta$documentChanged !== void 0 ? _meta$documentChanged : tr.docChanged;
+  const previousCandidates = mapCandidates(previousState, tr, retain);
+  const dirty = (candidate, position) => {
+    const currentNode = newState.doc.nodeAt(position);
+    const currentContextRevision = getActiveRevision(activeNodeAt(position));
+    return activeChanged || candidate.contextRevision !== currentContextRevision || candidate.nodeRef !== currentNode || isInvalidated(candidate, position, invalidation, changedRange);
+  };
+  if (surfaces.length === 0) {
+    const noCandidates = previousCandidates.size === 0;
+    if (noCandidates && previousState.positions.length === 0 && samePositions(visiblePositions, previousState.visiblePositions) && activeRevision === previousState.activeRevision && protectedPositions === previousState.protectedPositions) {
+      return previousState;
+    }
+    return {
+      activeRevision,
+      candidates: noCandidates ? previousState.candidates : EMPTY_CANDIDATES,
+      positions: EMPTY_POSITIONS,
+      protectedPositions,
+      visiblePositions
+    };
+  }
+  for (const [position, candidate] of previousCandidates) {
+    if (dirty(candidate, position)) {
+      addCandidateAt({
+        candidates: previousCandidates,
+        position,
+        state: newState,
+        surfaces,
+        activeNode: activeNodeAt(position)
+      });
+      const updatedCandidate = previousCandidates.get(position);
+      if (updatedCandidate && !retain(position, updatedCandidate)) {
+        previousCandidates.delete(position);
+      }
+    }
+  }
+
+  // IO supplies exact visible positions. Iterate those positions directly so a long visible
+  // container cannot cause a traversal of its entire nested document.
+  if (visiblePositionsChanged || documentChanged || invalidation !== null && invalidation !== void 0 && invalidation.all || changedRange) {
+    for (const position of visiblePositions) {
+      if (!previousCandidates.has(position)) {
+        addCandidateAt({
+          candidates: previousCandidates,
+          position,
+          state: newState,
+          surfaces,
+          activeNode: activeNodeAt(position)
+        });
+      }
+    }
+  }
+  const directPositions = new Set([...protectedSet, ...((_invalidation$positio2 = invalidation === null || invalidation === void 0 ? void 0 : invalidation.positions) !== null && _invalidation$positio2 !== void 0 ? _invalidation$positio2 : [])]);
+  for (const position of directPositions) {
+    if (retain(position) && !previousCandidates.has(position)) {
+      addCandidateAt({
+        candidates: previousCandidates,
+        position,
+        state: newState,
+        surfaces,
+        activeNode: activeNodeAt(position)
+      });
+    }
+  }
+  const positions = getPositions(previousCandidates);
+  if (sameCandidateMap(previousState.candidates, previousCandidates) && samePositions(previousState.positions, positions) && samePositions(previousState.visiblePositions, visiblePositions) && activeRevision === previousState.activeRevision && protectedPositions === previousState.protectedPositions) {
+    return previousState;
+  }
+  return {
+    activeRevision,
+    candidates: sameCandidateMap(previousState.candidates, previousCandidates) ? previousState.candidates : previousCandidates,
+    positions: samePositions(previousState.positions, positions) ? previousState.positions : positions,
+    protectedPositions,
+    visiblePositions
+  };
+};

package/dist/es2019/pm-plugins/utils/sparse-surfaces-mapping.js

@@ -0,0 +1,78 @@
+import { mapSparseSurfaceCandidates } from './sparse-surface-candidates';
+const mergeInvalidation = ({
+  current,
+  incoming,
+  tr
+}) => {
+  var _current$ids, _incoming$ids, _current$positions, _incoming$positions, _current$ranges, _incoming$ranges;
+  if (!current && !incoming) {
+    return undefined;
+  }
+  if (!incoming && !tr.docChanged) {
+    return current;
+  }
+  const ids = [...((_current$ids = current === null || current === void 0 ? void 0 : current.ids) !== null && _current$ids !== void 0 ? _current$ids : []), ...((_incoming$ids = incoming === null || incoming === void 0 ? void 0 : incoming.ids) !== null && _incoming$ids !== void 0 ? _incoming$ids : [])];
+  const positions = [...((_current$positions = current === null || current === void 0 ? void 0 : current.positions) !== null && _current$positions !== void 0 ? _current$positions : []).map(position => tr.mapping.map(position, 1)), ...((_incoming$positions = incoming === null || incoming === void 0 ? void 0 : incoming.positions) !== null && _incoming$positions !== void 0 ? _incoming$positions : [])];
+  const ranges = [...((_current$ranges = current === null || current === void 0 ? void 0 : current.ranges) !== null && _current$ranges !== void 0 ? _current$ranges : []).map(({
+    from,
+    to
+  }) => ({
+    from: tr.mapping.map(from, -1),
+    to: tr.mapping.map(to, 1)
+  })), ...((_incoming$ranges = incoming === null || incoming === void 0 ? void 0 : incoming.ranges) !== null && _incoming$ranges !== void 0 ? _incoming$ranges : [])];
+  return ids.length || positions.length || ranges.length ? {
+    ids,
+    positions,
+    ranges
+  } : undefined;
+};
+const mapAnchors = (anchors, tr) => {
+  if (!tr.docChanged || anchors.size === 0) {
+    return anchors;
+  }
+  let changed = false;
+  const mappedAnchors = new Map();
+  for (const [position, name] of anchors) {
+    const mapped = tr.mapping.mapResult(position, 1);
+    if (!mapped.deleted) {
+      mappedAnchors.set(mapped.pos, name);
+      changed ||= mapped.pos !== position;
+    } else {
+      changed = true;
+    }
+  }
+  return changed ? mappedAnchors : anchors;
+};
+export const reducePendingState = ({
+  invalidation,
+  previous,
+  tr
+}) => ({
+  invalidation: mergeInvalidation({
+    current: previous.invalidation,
+    incoming: invalidation,
+    tr
+  })
+});
+export const isUnchangedTransaction = ({
+  pending,
+  previous,
+  tr
+}) => !tr.docChanged && pending.invalidation === previous.invalidation;
+export const mapTransactionState = ({
+  newState,
+  pending,
+  previous,
+  tr
+}) => ({
+  ...previous,
+  anchors: mapAnchors(previous.anchors, tr),
+  candidates: tr.docChanged ? mapSparseSurfaceCandidates({
+    newState,
+    previousState: previous.candidates,
+    tr
+  }) : previous.candidates,
+  decorations: tr.docChanged ? previous.decorations.map(tr.mapping, tr.doc) : previous.decorations,
+  documentChanged: previous.documentChanged || tr.docChanged,
+  invalidation: pending.invalidation
+});

package/dist/es2019/pm-plugins/utils/sparse-surfaces-state.js

@@ -0,0 +1,39 @@
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { isUnchangedTransaction, mapTransactionState, reducePendingState } from './sparse-surfaces-mapping';
+export const createInitialSparseSurfacesState = candidates => ({
+  activeNodesByPosition: new Map(),
+  anchors: new Map(),
+  candidates,
+  decorations: DecorationSet.empty,
+  documentChanged: false
+});
+const isReconciliationCommit = meta => (meta === null || meta === void 0 ? void 0 : meta.type) === 'commitReconciliation';
+const commitReconciliation = (previous, meta) => ({
+  ...previous,
+  ...meta.reconciliation,
+  documentChanged: false,
+  invalidation: undefined
+});
+export const applySparseSurfacesTransaction = input => {
+  if (isReconciliationCommit(input.meta)) {
+    return commitReconciliation(input.previous, input.meta);
+  }
+  const pending = reducePendingState({
+    invalidation: input.invalidation,
+    previous: input.previous,
+    tr: input.tr
+  });
+  if (isUnchangedTransaction({
+    pending,
+    previous: input.previous,
+    tr: input.tr
+  })) {
+    return input.previous;
+  }
+  return mapTransactionState({
+    newState: input.newState,
+    pending,
+    previous: input.previous,
+    tr: input.tr
+  });
+};

package/dist/es2019/pm-plugins/utils/sparse-surfaces-view.js

@@ -0,0 +1,121 @@
+import { BLOCK_CONTROLS_LEFT_SURFACE, BLOCK_CONTROLS_RIGHT_SURFACE } from '@atlaskit/editor-common/block-controls/surface-keys';
+import { getNodeIdProvider } from '@atlaskit/editor-common/node-anchor';
+import { resolveSurface } from '@atlaskit/editor-ui-control-model/surface-renderer';
+import { createSurfaceAnchorDecorations } from '../decorations-surface-anchor';
+import { key as blockControlsKey } from '../main';
+import { reconcileSparseSurfaceCandidates } from './sparse-surface-candidates';
+import { observeSurfaceViewport } from './surface-viewport';
+const haveAnchorPositionsChanged = (positions, anchors) => positions.length !== anchors.size || positions.some(position => !anchors.has(position));
+export const createSparseSurfacesView = ({
+  api,
+  pluginKey,
+  view
+}) => {
+  var _api$uiControlRegistr3, _api$editorDisabled, _api$editorViewMode, _api$limitedMode2, _api$showDiff, _api$userIntent;
+  const win = view.dom.ownerDocument.defaultView;
+  let frame;
+  let visiblePositions = [];
+  let registryChanged = true;
+  const reconcile = () => {
+    var _api$limitedMode, _api$limitedMode$shar;
+    frame = undefined;
+    const previous = pluginKey.getState(view.state);
+    if (!previous || api !== null && api !== void 0 && (_api$limitedMode = api.limitedMode) !== null && _api$limitedMode !== void 0 && (_api$limitedMode$shar = _api$limitedMode.sharedState.currentState()) !== null && _api$limitedMode$shar !== void 0 && _api$limitedMode$shar.enabled) {
+      return;
+    }
+    const controls = blockControlsKey.getState(view.state);
+    const activeNode = controls === null || controls === void 0 ? void 0 : controls.activeNode;
+    const activeNodesByPosition = new Map();
+    const menu = controls !== null && controls !== void 0 && controls.isMenuOpen ? controls.menuTriggerByNode : undefined;
+    if (menu && controls !== null && controls !== void 0 && controls.menuTriggerBy && view.state.doc.nodeAt(menu.pos)) {
+      var _menu$rootPos;
+      const menuNode = {
+        ...menu,
+        anchorName: controls.menuTriggerBy
+      };
+      activeNodesByPosition.set(menu.pos, menuNode);
+      activeNodesByPosition.set((_menu$rootPos = menu.rootPos) !== null && _menu$rootPos !== void 0 ? _menu$rootPos : menu.pos, menuNode);
+    }
+    const resolvedSurfaces = [BLOCK_CONTROLS_LEFT_SURFACE, BLOCK_CONTROLS_RIGHT_SURFACE].map(surface => {
+      var _api$uiControlRegistr, _api$uiControlRegistr2;
+      return resolveSurface((_api$uiControlRegistr = api === null || api === void 0 ? void 0 : (_api$uiControlRegistr2 = api.uiControlRegistry) === null || _api$uiControlRegistr2 === void 0 ? void 0 : _api$uiControlRegistr2.actions.getComponents(surface)) !== null && _api$uiControlRegistr !== void 0 ? _api$uiControlRegistr : [], surface);
+    });
+    const candidates = reconcileSparseSurfaceCandidates({
+      activeNode,
+      activeNodesByPosition,
+      newState: view.state,
+      state: previous.candidates,
+      visiblePositions,
+      protectedPositions: [...activeNodesByPosition.keys()],
+      resolvedSurfaces,
+      documentChanged: previous.documentChanged,
+      invalidation: {
+        ...previous.invalidation,
+        all: registryChanged
+      }
+    });
+    const visibilityChanged = registryChanged;
+    registryChanged = false;
+    const anchorPositions = candidates.positions;
+    if (!visibilityChanged && !haveAnchorPositionsChanged(anchorPositions, previous.anchors) && candidates === previous.candidates && !previous.documentChanged && !previous.invalidation) {
+      return;
+    }
+    const nodeIdProvider = getNodeIdProvider(view);
+    const {
+      anchors,
+      decorations
+    } = createSurfaceAnchorDecorations(view.state, anchorPositions, (node, position, previousAnchorName) => {
+      if (previousAnchorName) {
+        nodeIdProvider.setIdForNode(node, previousAnchorName);
+        return previousAnchorName;
+      }
+      return nodeIdProvider.getOrGenerateId(node, position);
+    }, previous.anchors);
+    view.dispatch(view.state.tr.setMeta(pluginKey, {
+      reconciliation: {
+        activeNodesByPosition,
+        anchors,
+        candidates,
+        decorations
+      },
+      type: 'commitReconciliation'
+    }));
+  };
+  const schedule = () => {
+    if (frame === undefined && win) {
+      frame = win.requestAnimationFrame(reconcile);
+    }
+  };
+  const observer = observeSurfaceViewport(view, positions => {
+    visiblePositions = positions;
+    schedule();
+  });
+  const invalidate = () => {
+    registryChanged = true;
+    schedule();
+  };
+  const unsubscribe = api === null || api === void 0 ? void 0 : (_api$uiControlRegistr3 = api.uiControlRegistry) === null || _api$uiControlRegistr3 === void 0 ? void 0 : _api$uiControlRegistr3.actions.subscribe(invalidate);
+  const unsubscribers = [api === null || api === void 0 ? void 0 : (_api$editorDisabled = api.editorDisabled) === null || _api$editorDisabled === void 0 ? void 0 : _api$editorDisabled.sharedState.onChange(invalidate), api === null || api === void 0 ? void 0 : (_api$editorViewMode = api.editorViewMode) === null || _api$editorViewMode === void 0 ? void 0 : _api$editorViewMode.sharedState.onChange(invalidate), api === null || api === void 0 ? void 0 : (_api$limitedMode2 = api.limitedMode) === null || _api$limitedMode2 === void 0 ? void 0 : _api$limitedMode2.sharedState.onChange(invalidate), api === null || api === void 0 ? void 0 : (_api$showDiff = api.showDiff) === null || _api$showDiff === void 0 ? void 0 : _api$showDiff.sharedState.onChange(invalidate), api === null || api === void 0 ? void 0 : (_api$userIntent = api.userIntent) === null || _api$userIntent === void 0 ? void 0 : _api$userIntent.sharedState.onChange(invalidate)];
+  return {
+    update(currentView, previousState) {
+      observer.update();
+      const sparse = pluginKey.getState(currentView.state);
+      const controls = blockControlsKey.getState(currentView.state);
+      const previousControls = blockControlsKey.getState(previousState);
+      if ((controls === null || controls === void 0 ? void 0 : controls.isDragging) !== (previousControls === null || previousControls === void 0 ? void 0 : previousControls.isDragging) || (controls === null || controls === void 0 ? void 0 : controls.isResizerResizing) !== (previousControls === null || previousControls === void 0 ? void 0 : previousControls.isResizerResizing)) {
+        invalidate();
+      }
+      if (sparse !== null && sparse !== void 0 && sparse.documentChanged || sparse !== null && sparse !== void 0 && sparse.invalidation || (controls === null || controls === void 0 ? void 0 : controls.activeNode) !== (previousControls === null || previousControls === void 0 ? void 0 : previousControls.activeNode) || (controls === null || controls === void 0 ? void 0 : controls.isMenuOpen) !== (previousControls === null || previousControls === void 0 ? void 0 : previousControls.isMenuOpen) || (controls === null || controls === void 0 ? void 0 : controls.menuTriggerByNode) !== (previousControls === null || previousControls === void 0 ? void 0 : previousControls.menuTriggerByNode)) {
+        schedule();
+      }
+    },
+    destroy() {
+      if (frame !== undefined) {
+        win === null || win === void 0 ? void 0 : win.cancelAnimationFrame(frame);
+      }
+      observer.destroy();
+      unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+      unsubscribers.forEach(unsubscribe => unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe());
+    }
+  };
+};