mirror of
https://github.com/ianstormtaylor/slate.git
synced 2025-08-29 18:09:49 +02:00
Remove normalization from transform calls
This commit is contained in:
@@ -38,41 +38,7 @@ export function insertNodeByKey(transform, key, index, node) {
|
||||
const path = document.getPath(key)
|
||||
const newPath = path.slice().push(index)
|
||||
|
||||
transform.insertNodeOperation(path, index, node)
|
||||
|
||||
// If the node is an inline void, the parent is a block, and the node will be
|
||||
// inserted at the block's edge, we need to add surrounding text nodes.
|
||||
if (node.kind == 'inline' && node.isVoid) {
|
||||
const parent = document.assertDescendant(key)
|
||||
|
||||
if (index == 0) {
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(key, index, text)
|
||||
}
|
||||
|
||||
if (index == parent.nodes.size) {
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(key, index + 1, text)
|
||||
}
|
||||
}
|
||||
|
||||
// If the node is a text node, and it is insert next to a text node, it should
|
||||
// be joined with it.
|
||||
if (node.kind == 'text') {
|
||||
const parent = document.assertDescendant(key)
|
||||
const previous = index == 0 ? null : parent.nodes.get(index - 1)
|
||||
const next = parent.nodes.get(index)
|
||||
|
||||
if (next && next.kind == 'text') {
|
||||
transform.joinNodeByKey(next.key, node.key)
|
||||
}
|
||||
|
||||
if (previous && previous.kind == 'text') {
|
||||
transform.joinNodeByKey(node.key, previous.key)
|
||||
}
|
||||
}
|
||||
|
||||
return transform
|
||||
return transform.insertNodeOperation(path, index, node)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -132,29 +98,6 @@ export function moveNodeByKey(transform, key, newKey, newIndex) {
|
||||
const next = parent.nodes.get(newIndex)
|
||||
transform.moveNodeOperation(path, newPath, newIndex)
|
||||
|
||||
// If the node to move is a text node, and it will be moved adjacent to
|
||||
// another text node, join them together.
|
||||
if (node.kind == 'text') {
|
||||
if (next && next.kind == 'text') {
|
||||
transform.joinNodeByKey(next.key, node.key)
|
||||
}
|
||||
|
||||
if (previous && previous.kind == 'text') {
|
||||
transform.joinNodeByKey(node.key, previous.key)
|
||||
}
|
||||
}
|
||||
|
||||
// If the node to be moved is the last child of its parent, then create a new
|
||||
// empty text node in its place.
|
||||
if (prevParent.nodes.size == 1) {
|
||||
if (prevParent.kind == 'block') {
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(prevParent.key, 0, text)
|
||||
} else {
|
||||
transform.removeNodeByKey(prevParent.key)
|
||||
}
|
||||
}
|
||||
|
||||
return transform
|
||||
}
|
||||
|
||||
@@ -193,24 +136,8 @@ export function removeNodeByKey(transform, key) {
|
||||
const parent = document.getParent(key)
|
||||
const previous = document.getPreviousSibling(key)
|
||||
const next = document.getNextSibling(key)
|
||||
transform.removeNodeOperation(path)
|
||||
|
||||
// If there are no more remaining nodes in the parent, re-add an empty text
|
||||
// node so that we guarantee to always have text nodes as the tree's leaves.
|
||||
if (parent.nodes.size == 1) {
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(parent.key, 0, text)
|
||||
}
|
||||
|
||||
// If the previous and next siblings are both text nodes, join them.
|
||||
if (
|
||||
(previous && previous.kind == 'text') &&
|
||||
(next && next.kind == 'text')
|
||||
) {
|
||||
transform.joinNodeByKey(next.key, previous.key)
|
||||
}
|
||||
|
||||
return transform
|
||||
return transform.removeNodeOperation(path)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -251,14 +178,6 @@ export function removeTextByKey(transform, key, offset, length) {
|
||||
transform.removeNodeByKey(parent.key)
|
||||
}
|
||||
|
||||
// Otherwise, if the text node is not needed in the tree any more, remove it.
|
||||
else if (
|
||||
(previous && previous.isVoid == false) ||
|
||||
(next && next.isVoid == false)
|
||||
) {
|
||||
transform.removeNodeByKey(key)
|
||||
}
|
||||
|
||||
return transform
|
||||
}
|
||||
|
||||
@@ -303,50 +222,6 @@ export function setNodeByKey(transform, key, properties) {
|
||||
const next = document.getNextSibling(key)
|
||||
transform.setNodeOperation(path, properties)
|
||||
|
||||
// If the `isVoid` property is being changed to true, remove all of the node's
|
||||
// children, and add additional text nodes around it if necessary.
|
||||
if (properties.isVoid == true && node.isVoid == false) {
|
||||
node.nodes.forEach((child) => {
|
||||
transform.removeNodeByKey(child.key)
|
||||
})
|
||||
|
||||
if (node.kind == 'inline') {
|
||||
if (!next) {
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(parent.key, index + 1, text)
|
||||
}
|
||||
|
||||
if (!previous) {
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(parent.key, index, text)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If the `isVoid` property is being changed to `false` and the node is an
|
||||
// inline node, remove any additional unnecessary text around it.
|
||||
if (
|
||||
properties.isVoid == false &&
|
||||
node.isVoid == true &&
|
||||
node.kind == 'inline'
|
||||
) {
|
||||
if (
|
||||
previous &&
|
||||
previous.kind == 'text' &&
|
||||
previous.text == ''
|
||||
) {
|
||||
transform.removeNodeByKey(previous.key)
|
||||
}
|
||||
|
||||
if (
|
||||
next &&
|
||||
next.kind == 'text' &&
|
||||
next.text == ''
|
||||
) {
|
||||
transform.removeNodeByKey(next.key)
|
||||
}
|
||||
}
|
||||
|
||||
return transform
|
||||
}
|
||||
|
||||
@@ -363,89 +238,8 @@ export function splitNodeByKey(transform, key, offset) {
|
||||
let { state } = transform
|
||||
let { document } = state
|
||||
const path = document.getPath(key)
|
||||
transform.splitNodeOperation(path, offset)
|
||||
|
||||
// Traverse the nodes on both sides of the split, ensuring that there are no
|
||||
// empty inline nodes, or empty text nodes that should be removed.
|
||||
state = transform.state
|
||||
document = state.document
|
||||
const parent = document.getParent(key)
|
||||
|
||||
// Define an iterator that will apply normalization transforms.
|
||||
parent.filterDescendants((d) => {
|
||||
|
||||
// We don't need to do any normalization for block nodes.
|
||||
if (d.kind == 'block') {
|
||||
return
|
||||
}
|
||||
|
||||
// If an inline void node has no text, add a space character.
|
||||
if (
|
||||
d.kind == 'inline' &&
|
||||
d.text == '' &&
|
||||
d.isVoid == true
|
||||
) {
|
||||
transform.insertTextByKey(d.key, 0, ' ')
|
||||
}
|
||||
|
||||
// If an non-void inline node has no text now, remove it.
|
||||
if (
|
||||
d.kind == 'inline' &&
|
||||
d.text == '' &&
|
||||
d.isVoid == false
|
||||
) {
|
||||
transform.removeNodeByKey(d.key)
|
||||
}
|
||||
|
||||
// Check to ensure that extra empty text nodes are preserved around inline
|
||||
// void nodes.
|
||||
if (
|
||||
d.kind == 'inline' &&
|
||||
d.isVoid == true
|
||||
) {
|
||||
const previous = document.getPreviousSibling(d)
|
||||
const next = document.getNextSibling(d)
|
||||
|
||||
if (
|
||||
(!previous) ||
|
||||
(previous.kind == 'block' || previous.kind == 'inline' && previous.isVoid)
|
||||
) {
|
||||
const p = document.getParent(d)
|
||||
const index = p.nodes.indexOf(d)
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(p, index, text)
|
||||
}
|
||||
|
||||
if (
|
||||
(!next) ||
|
||||
(next.kind == 'block' || next.kind == 'inline' && next.isVoid)
|
||||
) {
|
||||
const p = document.getParent(d)
|
||||
const index = p.nodes.indexOf(d)
|
||||
const text = Text.create()
|
||||
transform.insertNodeByKey(p, index + 1, text)
|
||||
}
|
||||
}
|
||||
|
||||
// If an empty text node is adjacent to an non-void inline node, remove it.
|
||||
if (
|
||||
d.kind == 'text' &&
|
||||
d.text == ''
|
||||
) {
|
||||
const previous = document.getPreviousSibling(d)
|
||||
const next = document.getNextSibling(d)
|
||||
|
||||
if (
|
||||
(previous && previous.kind == 'inline' && previous.isVoid == false) ||
|
||||
(next && next.kind == 'inline' && next.isVoid == false)
|
||||
) {
|
||||
transform.removeNodeByKey(d.key)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
// Return the transform.
|
||||
return transform
|
||||
return transform.splitNodeOperation(path, offset)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -462,5 +256,6 @@ export function unwrapInlineByKey(transform, key, properties) {
|
||||
const { document, selection } = state
|
||||
const node = document.assertDescendant(key)
|
||||
const range = selection.moveToRangeOf(node)
|
||||
|
||||
return transform.unwrapInline(range, properties)
|
||||
}
|
||||
|
Reference in New Issue
Block a user