mirror/slate
1
0
Fork 0
mirror of https://github.com/ianstormtaylor/slate.git synced 2025-08-30 10:29:48 +02:00
Code Issues Releases Wiki Activity

Remove normalization from transform calls

Browse Source
This commit is contained in:
Samy Pesse
2016-10-18 22:00:50 +02:00
parent a49f8e1bfa
commit 0246c3085b
1 changed files with 4 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
src/transforms/by-key.js
View File

@@ -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)
}