Normalise falsely surrounds non void inline nodes

[RXminuS]

I'm not sure if it's a bug, but the behaviour seems to deviate from the docs. In the docs it's suggested that only inlines that have isVoid must be surrounded by empty text nodes, but this normalisation function surrounds all inline nodes by text nodes.

slate/packages/slate/src/constants/core-schema-rules.js

Line 142 in 3741864

if (child.object !== 'inline') return list

I can either make a PR to fix the issue by a simple

if (child.object !== 'inline' || !child.isVoid) return list;

or change the docs to clarify that every inline node needs to be surrounded by text nodes.

The reason this is important is that I wrote a performance critical "serialize" function that is supposed to output a perfect tree to avoid unnecessary normalisation, and this added a full 3 seconds to the loading time.

[ianstormtaylor]

Ah yeah, all inlines are surrounded by text nodes I guess.

[adamlibusa]

Ah yeah, all inlines are surrounded by text nodes I guess.

Why is this a thing? Is it a deliberate design decision or is it simply a consequence of the way Slate is implemented? Reading throughout other issues: Is it like that to fix the keyboard selection problem across multiple inlines (#1502)?

[yonahforst]

@ianstormtaylor - I'm also curious if this is necessary for all inlines, or just void ones 😄

I have a large document with several hundred block nodes which I would like to convert to inline. All the insertions of empty text nodes causes the browser to hang.

I'm happy to submit a PR implementing what @RXminuS suggested above

[yonahforst]

I'm struggling a bit trying to apply this rule to only void inlines. Here's the schema:

slate/packages/slate/src/plugins/core.js

Lines 130 to 155 in cf46e9d

	{
	match: { object: 'inline' },
	first: [{ object: 'block' }, { object: 'text' }],
	last: [{ object: 'block' }, { object: 'text' }],
	previous: [{ object: 'block' }, { object: 'text' }],
	next: [{ object: 'block' }, { object: 'text' }],
	normalize: (editor, error) => {
	const { code, node, index } = error
	const text = Text.create()
	let i
	if (code === 'first_child_object_invalid') {
	i = 0
	} else if (code === 'last_child_object_invalid') {
	i = node.nodes.size
	} else if (code === 'previous_sibling_object_invalid') {
	i = index
	} else if (code === 'next_sibling_object_invalid') {
	i = index + 1
	} else {
	return
	}
	editor.insertNodeByKey(node.key, i, text)
	},
	},

What I can't figure out is how to tell the schema to match only when the inline is void.
If I add isVoid to the rule like so:

 { 
   isVoid: true,
   match: { object: 'inline' }, 
   first: [{ object: 'block' }, { object: 'text' }], 
   ...
}

that seems to tell the schema that the inline nodes must be void, otherwise they are invalid (instead of saying inline nodes that are void must match the following rules)

I also tried checking inside the normalize function if it's void and returning early, but it looks like the unless an operation is added to the editor, the default normalizer will run and the node will be removed.

So, I'm stuck 😅. I don't want to double my node count by adding a bunch of empty text nodes, but i also don't want to add the same number of setSelection commands just to get the rule to pass...

Any ideas? 🙏🏽

[ianstormtaylor]

I believe that this may be fixed by #3093, which has changed a lot of the logic in Slate and slate-react especially. I'm going to close this out, but as always, feel free to open a new issue if it persists for you. Thanks for understanding.