chore(blocks.render): mutex for onchange added to the blocks.render()

[neSpecc]

TL;DR

onChange won't be called on blocks.render(). Like in 2.27 and before.

Context

#2430 introduced a few updates:

• onChange mutex was removed from Renderer since Renderer.render() became awaitable and we just enable Modification Observer after initial rendering:

editor.js/src/components/core.ts

Lines 54 to 62 in be0d33c

	this.validate();
	this.init();
	await this.start();
	await this.render();
	const { BlockManager, Caret, UI, ModificationsObserver } = this.moduleInstances;
	UI.checkEmptiness();
	ModificationsObserver.enable();

So the onChange became enabled in the blocks.render() API

• blocks.clear() now triggers onChange with removed blocks
  

  editor.js/src/components/modules/blockManager.ts

  Lines 858 to 867 in be0d33c

  	public async clear(needToAddDefaultBlock = false): Promise<void> {
  	const queue = new PromiseQueue();
  	this.blocks.forEach((block) => {
  	queue.add(async () => {
  	await this.removeBlock(block, false);
  	});
  	});
  	await queue.completed;

Both of these changes are correct and actual. The initial render does not call onChange (because a document is not changed), but the blocks.render() calls it with removed and added blocks (because an existing document is cleared).

Problem

During the RC test we got feedback that the blocks.render() method is expected to be mutation-free.

Solution

I thought about it and found three solutions:

• add "silent" option to the render() method
• add new API for the onChange enabling/disabling
• just mute onChange inside the render()

After all, I've decided to mute onChange inside the render method for two pros:

• it is the same behavior that we have in current version 2.27, so 2.28 won't introduce a breaking change here.
• semantic meaning of the render() method is to display a new document instead of a current that stays unchanged.

Cons:

• It's not obvious that some methods lead onChange call, but some are not. I think that we need to redesign the API at all, based on the new Document Model in 3.0.

Also

blocks.clear() now returns a promise. So we can call it before render as a workaround if we want to receive "block-removed" events

await editor.blocks.clear(); // onChange will be called
await editor.blocks.render();