mirror/slate
1
0
Fork 0
mirror of https://github.com/ianstormtaylor/slate.git synced 2025-08-19 13:41:19 +02:00
Code Issues Releases Wiki Activity

Merge pull request #447 from ianstormtaylor/refactor-transforms

Browse Source 
Refactor transforms
This commit is contained in:
Ian Storm Taylor
2016-11-22 17:50:13 -08:00
committed by GitHub
parent 5530b54c3b 5b81f0bd84
commit 0b35a8b885
11 changed files with 338 additions and 675 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/models/node.js
View File

@@ -387,6 +387,9 @@ const Node = {
*/
getCommonAncestor(one, two) {
if (one == this.key) return this
if (two == this.key) return this
this.assertDescendant(one)
this.assertDescendant(two)
let ancestors = new List()

3
src/models/transform.js
View File

@@ -99,7 +99,8 @@ class Transform {
Object.keys(Transforms).forEach((type) => {
Transform.prototype[type] = function (...args) {
debug(type, { args })
return Transforms[type](this, ...args)
Transforms[type](this, ...args)
return this
}
})

13
src/transforms/apply-operation.js
View File

@@ -40,7 +40,6 @@ const OPERATIONS = {
*
* @param {Transform} transform
* @param {Object} operation
* @return {Transform}
*/
export function applyOperation(transform, operation) {
@@ -53,11 +52,8 @@ export function applyOperation(transform, operation) {
}
debug(type, operation)
transform.state = fn(state, operation)
transform.operations = operations.concat([operation])
return transform
}
/**
@@ -289,16 +285,11 @@ function removeNode(state, operation) {
function removeText(state, operation) {
const { path, offset, length } = operation
const rangeOffset = offset + length
let { document, selection } = state
const { startKey, endKey, startOffset, endOffset } = selection
let node = document.assertPath(path)
const rangeOffset = offset + length
// Update the document
node = node.removeText(offset, length)
document = document.updateDescendant(node)
// Update the selection
if (startKey == node.key && startOffset >= rangeOffset) {
selection = selection.moveStartOffset(-length)
@@ -307,6 +298,8 @@ function removeText(state, operation) {
selection = selection.moveEndOffset(-length)
}
node = node.removeText(offset, length)
document = document.updateDescendant(node)
state = state.merge({ document, selection })
return state
}

328
src/transforms/at-current-range.js
View File

@@ -6,99 +6,48 @@ import Normalize from '../utils/normalize'
*
* @param {Transform} transform
* @param {Mark} mark
* @return {Transform}
*/
export function addMark(transform, mark) {
mark = Normalize.mark(mark)
const { state } = transform
const { document, selection } = state
if (selection.isExpanded) {
return transform.addMarkAtRange(selection, mark)
transform.addMarkAtRange(selection, mark)
return
}
else if (selection.marks) {
if (selection.marks) {
const marks = selection.marks.add(mark)
const sel = selection.merge({ marks })
return transform.moveTo(sel)
transform.moveTo(sel)
return
}
else {
const marks = document.getMarksAtRange(selection).add(mark)
const sel = selection.merge({ marks })
return transform.moveTo(sel)
}
const marks = document.getMarksAtRange(selection).add(mark)
const sel = selection.merge({ marks })
transform.moveTo(sel)
}
/**
* Delete at the current selection.
*
* @param {Transform} transform
* @return {Transform}
*/
export function _delete(transform) {
const { state } = transform
const { document, selection } = state
const { selection } = state
if (selection.isCollapsed) return
// If the selection is collapsed, there's nothing to delete.
if (selection.isCollapsed) return transform
const { startText } = state
const { startKey, startOffset, endKey, endOffset } = selection
const block = document.getClosestBlock(startKey)
const highest = block.getHighestChild(startKey)
const previous = block.getPreviousSibling(highest.key)
const next = block.getNextSibling(highest.key)
let after
// If there's a previous node, and we're at the start of the current node,
// and the selection encompasses the entire current node, it won't exist after
// deleting, so we need to update the selection's keys.
if (
previous &&
startOffset == 0 &&
(endKey != startKey || endOffset == startText.length)
) {
// If the nodes on either sides are text nodes, they will end up being
// combined, so we need to set the selection to right in between them.
if (previous.kind == 'text' && next && next.kind == 'text') {
after = selection.merge({
anchorKey: previous.key,
anchorOffset: previous.length,
focusKey: previous.key,
focusOffset: previous.length
})
}
// Otherwise, if only the previous node is a text node, it won't be merged,
// so collapse to the end of it.
else if (previous.kind == 'text') {
after = selection.collapseToEndOf(previous)
}
// Otherwise, if the previous node isn't a text node, we need to get the
// last text node inside of it and collapse to the end of that.
else {
const last = previous.getLastText()
after = selection.collapseToEndOf(last)
}
}
// Otherwise, if the inline is an online child
// Otherwise simply collapse the selection.
else {
after = selection.collapseToStart()
}
return transform
.unsetSelection()
transform
.snapshotSelection()
.deleteAtRange(selection)
.moveTo(after)
// Ensure that the selection is collapsed to the start, because in certain
// cases when deleting across inline nodes this isn't guaranteed.
.collapseToStart()
.snapshotSelection()
}
/**
@@ -106,16 +55,12 @@ export function _delete(transform) {
*
* @param {Transform} transform
* @param {Number} n (optional)
* @return {Transform}
*/
export function deleteBackward(transform, n = 1) {
const { state } = transform
const { selection } = state
return transform
.deleteBackwardAtRange(selection, n)
.collapseToEnd()
transform.deleteBackwardAtRange(selection, n)
}
/**
@@ -123,16 +68,12 @@ export function deleteBackward(transform, n = 1) {
*
* @param {Transform} transform
* @param {Number} n (optional)
* @return {Transform}
*/
export function deleteForward(transform, n = 1) {
const { state } = transform
const { selection } = state
return transform
.deleteForwardAtRange(selection, n)
.collapseToEnd()
transform.deleteForwardAtRange(selection, n)
}
/**
@@ -140,23 +81,17 @@ export function deleteForward(transform, n = 1) {
*
* @param {Transform} transform
* @param {String|Object|Block} block
* @return {Transform}
*/
export function insertBlock(transform, block) {
let { state } = transform
let { document, selection } = state
const keys = document.getTexts().map(text => text.key)
transform.unsetSelection()
block = Normalize.block(block)
const { state } = transform
const { selection } = state
transform.insertBlockAtRange(selection, block)
state = transform.state
document = state.document
const text = document.getTexts().find(n => !keys.includes(n.key))
const after = selection.collapseToEndOf(text)
return transform.moveTo(after)
// If the node was successfully inserted, update the selection.
const node = transform.state.document.getNode(block.key)
if (node) transform.collapseToEndOf(node)
}
/**
@@ -164,14 +99,13 @@ export function insertBlock(transform, block) {
*
* @param {Transform} transform
* @param {Document} fragment
* @return {Transform}
*/
export function insertFragment(transform, fragment) {
let { state } = transform
let { document, selection } = state
if (!fragment.length) return transform
if (!fragment.length) return
const { startText, endText } = state
const lastText = fragment.getLastText()
@@ -207,7 +141,7 @@ export function insertFragment(transform, fragment) {
.moveForward(lastText.length)
}
return transform.moveTo(after)
transform.moveTo(after)
}
/**
@@ -215,38 +149,17 @@ export function insertFragment(transform, fragment) {
*
* @param {Transform} transform
* @param {String|Object|Block} inline
* @return {Transform}
*/
export function insertInline(transform, inline) {
let { state } = transform
let { document, selection, startText } = state
let after
const hasVoid = document.hasVoidParent(startText.key)
const keys = document.getTexts().map(text => text.key)
transform.unsetSelection()
inline = Normalize.inline(inline)
const { state } = transform
const { selection } = state
transform.insertInlineAtRange(selection, inline)
state = transform.state
document = state.document
if (hasVoid) {
after = selection
}
else {
const text = document.getTexts().find((n) => {
if (keys.includes(n.key)) return false
const parent = document.getParent(n.key)
if (parent.kind != 'inline') return false
return true
})
after = selection.collapseToEndOf(text)
}
return transform.moveTo(after)
// If the node was successfully inserted, update the selection.
const node = transform.state.document.getNode(inline.key)
if (node) transform.collapseToEndOf(node)
}
/**
@@ -255,34 +168,19 @@ export function insertInline(transform, inline) {
* @param {Transform} transform
* @param {String} text
* @param {Set<Mark>} marks (optional)
* @return {Transform}
*/
export function insertText(transform, text, marks) {
const { state } = transform
const { document, selection } = state
const { startKey } = selection
const isVoid = document.hasVoidParent(startKey)
let after
if (isVoid) {
after = selection
}
else if (selection.isExpanded) {
after = selection.collapseToStart().moveForward(text.length)
}
else {
after = selection.moveForward(text.length)
}
marks = marks || selection.marks
transform.insertTextAtRange(selection, text, marks)
return transform
.unsetSelection()
.insertTextAtRange(selection, text, marks)
.moveTo(after)
// If the text was successfully inserted, and the selection had marks on it,
// unset the selection's marks.
if (selection.marks && document != transform.state.document) {
transform.unsetMarks()
}
}
/**
@@ -290,13 +188,12 @@ export function insertText(transform, text, marks) {
*
* @param {Transform} transform
* @param {Object} properties
* @return {Transform}
*/
export function setBlock(transform, properties) {
const { state } = transform
const { selection } = state
return transform.setBlockAtRange(selection, properties)
transform.setBlockAtRange(selection, properties)
}
/**
@@ -304,13 +201,12 @@ export function setBlock(transform, properties) {
*
* @param {Transform} transform
* @param {Object} properties
* @return {Transform}
*/
export function setInline(transform, properties) {
const { state } = transform
const { selection } = state
return transform.setInlineAtRange(selection, properties)
transform.setInlineAtRange(selection, properties)
}
/**
@@ -318,43 +214,16 @@ export function setInline(transform, properties) {
*
* @param {Transform} transform
* @param {Number} depth (optional)
* @return {Transform}
*/
export function splitBlock(transform, depth = 1) {
let { state } = transform
let { document, selection } = state
transform.unsetSelection()
transform.splitBlockAtRange(selection, depth)
state = transform.state
document = state.document
const { startKey, startOffset } = selection
const startText = document.getNode(startKey)
const startBlock = document.getClosestBlock(startKey)
const startInline = startBlock.getFurthestInline(startKey)
const nextText = document.getNextText(startText.key)
let after
// If the selection is at the start of the highest inline child inside the
// block, the starting text node won't need to be split.
if (
(startOffset == 0) &&
(startBlock.text != '') &&
(!startInline || startInline.getOffset(startText.key) == 0)
) {
after = selection.collapseToStartOf(startText)
}
// Otherwise, we'll need to move the selection forward one to account for the
// text node that was split.
else {
after = selection.collapseToStartOf(nextText)
}
return transform.moveTo(after)
let { selection } = state
transform
.snapshotSelection()
.splitBlockAtRange(selection, depth)
.collapseToEnd()
.snapshotSelection()
}
/**
@@ -362,49 +231,15 @@ export function splitBlock(transform, depth = 1) {
*
* @param {Transform} transform
* @param {Number} depth (optional)
* @return {Transform}
*/
export function splitInline(transform, depth = Infinity) {
let { state } = transform
let { document, selection } = state
// If the selection is expanded, remove it first.
if (selection.isExpanded) {
transform.delete()
state = transform.state
document = state.document
selection = state.selection
}
let after = selection
const { startKey, startOffset } = selection
let startNode = document.assertDescendant(startKey)
const furthestInline = document.getFurthestInline(startKey)
const offset = furthestInline.getOffset(startNode.key)
// If the selection is at the start of end of the furthest inline, there isn't
// anything to split, so abort.
if (
(offset + startOffset == 0) ||
(offset + startNode.length == startOffset)
) {
return transform
}
transform.unsetSelection()
transform.splitInlineAtRange(selection, depth)
state = transform.state
document = state.document
const closestInline = document.getClosestInline(startKey)
if (closestInline) {
startNode = document.getDescendant(startKey)
const nextNode = document.getNextText(startNode.key)
after = selection.collapseToStartOf(nextNode)
}
return transform.moveTo(after)
let { selection } = state
transform
.snapshotSelection()
.splitInlineAtRange(selection, depth)
.snapshotSelection()
}
/**
@@ -412,30 +247,28 @@ export function splitInline(transform, depth = Infinity) {
*
* @param {Transform} transform
* @param {Mark} mark
* @return {Transform}
*/
export function removeMark(transform, mark) {
mark = Normalize.mark(mark)
const { state } = transform
const { document, selection } = state
if (selection.isExpanded) {
return transform.removeMarkAtRange(selection, mark)
transform.removeMarkAtRange(selection, mark)
return
}
else if (selection.marks) {
if (selection.marks) {
const marks = selection.marks.remove(mark)
const sel = selection.merge({ marks })
return transform.moveTo(sel)
transform.moveTo(sel)
return
}
else {
const marks = document.getMarksAtRange(selection).remove(mark)
const sel = selection.merge({ marks })
return transform.moveTo(sel)
}
const marks = document.getMarksAtRange(selection).remove(mark)
const sel = selection.merge({ marks })
transform.moveTo(sel)
}
/**
@@ -444,19 +277,17 @@ export function removeMark(transform, mark) {
*
* @param {Transform} transform
* @param {Mark} mark
* @return {Transform}
*/
export function toggleMark(transform, mark) {
mark = Normalize.mark(mark)
const { state } = transform
const exists = state.marks.some(m => m.equals(mark))
if (exists) {
return transform.removeMark(mark)
transform.removeMark(mark)
} else {
return transform.addMark(mark)
transform.addMark(mark)
}
}
@@ -465,13 +296,12 @@ export function toggleMark(transform, mark) {
*
* @param {Transform} transform
* @param {Object|String} properties
* @return {Transform}
*/
export function unwrapBlock(transform, properties) {
const { state } = transform
const { selection } = state
return transform.unwrapBlockAtRange(selection, properties)
transform.unwrapBlockAtRange(selection, properties)
}
/**
@@ -479,13 +309,12 @@ export function unwrapBlock(transform, properties) {
*
* @param {Transform} transform
* @param {Object|String} properties
* @return {Transform}
*/
export function unwrapInline(transform, properties) {
const { state } = transform
const { selection } = state
return transform.unwrapInlineAtRange(selection, properties)
transform.unwrapInlineAtRange(selection, properties)
}
/**
@@ -494,13 +323,12 @@ export function unwrapInline(transform, properties) {
*
* @param {Transform} transform
* @param {Object|String} properties
* @return {Transform}
*/
export function wrapBlock(transform, properties) {
const { state } = transform
const { selection } = state
return transform.wrapBlockAtRange(selection, properties)
transform.wrapBlockAtRange(selection, properties)
}
/**
@@ -508,7 +336,6 @@ export function wrapBlock(transform, properties) {
*
* @param {Transform} transform
* @param {Object|String} properties
* @return {Transform}
*/
export function wrapInline(transform, properties) {
@@ -551,7 +378,7 @@ export function wrapInline(transform, properties) {
}
after = after.normalize(document)
return transform.moveTo(after)
transform.moveTo(after)
}
/**
@@ -560,28 +387,19 @@ export function wrapInline(transform, properties) {
* @param {Transform} transform
* @param {String} prefix
* @param {String} suffix
* @return {Transform}
*/
export function wrapText(transform, prefix, suffix = prefix) {
const { state } = transform
const { selection } = state
const { anchorOffset, anchorKey, focusOffset, focusKey, isBackward } = selection
let after
transform.wrapTextAtRange(selection, prefix, suffix)
if (anchorKey == focusKey) {
after = selection.moveForward(prefix.length)
// Adding the suffix will have pushed the end of the selection further on, so
// we need to move it back to account for this.
transform.moveEndOffset(0 - suffix.length)
// If the selection was collapsed, it will have moved the start offset too.
if (selection.isCollapsed) {
transform.moveStartOffset(0 - prefix.length)
}
else {
after = selection.merge({
anchorOffset: isBackward ? anchorOffset : anchorOffset + prefix.length,
focusOffset: isBackward ? focusOffset + prefix.length : focusOffset
})
}
return transform
.unsetSelection()
.wrapTextAtRange(selection, prefix, suffix)
.moveTo(after)
}

211
src/transforms/at-range.js
View File

@@ -4,6 +4,16 @@ import Normalize from '../utils/normalize'
import SCHEMA from '../schemas/core'
import { List } from 'immutable'
/**
* An options object with normalize set to `false`.
*
* @type {Object}
*/
const OPTS = {
normalize: false
}
/**
* Add a new `mark` to the characters at `range`.
*
@@ -12,11 +22,10 @@ import { List } from 'immutable'
* @param {Mixed} mark
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function addMarkAtRange(transform, range, mark, options = {}) {
if (range.isCollapsed) return transform
if (range.isCollapsed) return
const { normalize = true } = options
const { state } = transform
@@ -35,8 +44,6 @@ export function addMarkAtRange(transform, range, mark, options = {}) {
transform.addMarkByKey(key, index, length, mark, { normalize })
})
return transform
}
/**
@@ -46,11 +53,10 @@ export function addMarkAtRange(transform, range, mark, options = {}) {
* @param {Selection} range
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function deleteAtRange(transform, range, options = {}) {
if (range.isCollapsed) return transform
if (range.isCollapsed) return
const { normalize = true } = options
const { startKey, startOffset, endKey, endOffset } = range
@@ -58,7 +64,8 @@ export function deleteAtRange(transform, range, options = {}) {
if (startKey == endKey) {
const index = startOffset
const length = endOffset - startOffset
return transform.removeTextByKey(startKey, index, length, { normalize })
transform.removeTextByKey(startKey, index, length, { normalize })
return
}
let { state } = transform
@@ -71,8 +78,8 @@ export function deleteAtRange(transform, range, options = {}) {
const startOff = (startChild.kind == 'text' ? 0 : startChild.getOffset(startKey)) + startOffset
const endOff = (endChild.kind == 'text' ? 0 : endChild.getOffset(endKey)) + endOffset
transform.splitNodeByKey(startChild.key, startOff, { normalize: false })
transform.splitNodeByKey(endChild.key, endOff, { normalize: false })
transform.splitNodeByKey(startChild.key, startOff, OPTS)
transform.splitNodeByKey(endChild.key, endOff, OPTS)
state = transform.state
document = state.document
@@ -90,7 +97,7 @@ export function deleteAtRange(transform, range, options = {}) {
if (middles.size) {
// remove first nodes directly so the document is not normalized
middles.forEach(child => {
transform.removeNodeByKey(child.key, { normalize: false })
transform.removeNodeByKey(child.key, OPTS)
})
}
@@ -98,18 +105,16 @@ export function deleteAtRange(transform, range, options = {}) {
endBlock.nodes.forEach((child, i) => {
const newKey = startBlock.key
const newIndex = startBlock.nodes.size + i
transform.moveNodeByKey(child.key, newKey, newIndex, { normalize: false })
transform.moveNodeByKey(child.key, newKey, newIndex, OPTS)
})
const lonely = document.getFurthest(endBlock.key, p => p.nodes.size == 1) || endBlock
transform.removeNodeByKey(lonely.key, { normalize: false })
transform.removeNodeByKey(lonely.key, OPTS)
}
if (normalize) {
transform.normalizeNodeByKey(ancestor.key, SCHEMA)
}
return transform
}
/**
@@ -120,7 +125,6 @@ export function deleteAtRange(transform, range, options = {}) {
* @param {Number} n (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function deleteBackwardAtRange(transform, range, n = 1, options = {}) {
@@ -130,21 +134,24 @@ export function deleteBackwardAtRange(transform, range, n = 1, options = {}) {
const { startKey, focusOffset } = range
if (range.isExpanded) {
return transform.deleteAtRange(range, { normalize })
transform.deleteAtRange(range, { normalize })
return
}
const block = document.getClosestBlock(startKey)
if (block && block.isVoid) {
return transform.removeNodeByKey(block.key, { normalize })
transform.removeNodeByKey(block.key, { normalize })
return
}
const inline = document.getClosestInline(startKey)
if (inline && inline.isVoid) {
return transform.removeNodeByKey(inline.key, { normalize })
transform.removeNodeByKey(inline.key, { normalize })
return
}
if (range.isAtStartOf(document)) {
return transform
return
}
const text = document.getDescendant(startKey)
@@ -154,11 +161,13 @@ export function deleteBackwardAtRange(transform, range, n = 1, options = {}) {
const prevInline = document.getClosestInline(prev.key)
if (prevBlock && prevBlock.isVoid) {
return transform.removeNodeByKey(prevBlock.key, { normalize })
transform.removeNodeByKey(prevBlock.key, { normalize })
return
}
if (prevInline && prevInline.isVoid) {
return transform.removeNodeByKey(prevInline.key, { normalize })
transform.removeNodeByKey(prevInline.key, { normalize })
return
}
range = range.merge({
@@ -166,7 +175,8 @@ export function deleteBackwardAtRange(transform, range, n = 1, options = {}) {
anchorOffset: prev.length,
})
return transform.deleteAtRange(range, { normalize })
transform.deleteAtRange(range, { normalize })
return
}
range = range.merge({
@@ -174,7 +184,7 @@ export function deleteBackwardAtRange(transform, range, n = 1, options = {}) {
isBackward: true,
})
return transform.deleteAtRange(range, { normalize })
transform.deleteAtRange(range, { normalize })
}
/**
@@ -185,7 +195,6 @@ export function deleteBackwardAtRange(transform, range, n = 1, options = {}) {
* @param {Number} n (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function deleteForwardAtRange(transform, range, n = 1, options = {}) {
@@ -195,21 +204,24 @@ export function deleteForwardAtRange(transform, range, n = 1, options = {}) {
const { startKey, focusOffset } = range
if (range.isExpanded) {
return transform.deleteAtRange(range, { normalize })
transform.deleteAtRange(range, { normalize })
return
}
const block = document.getClosestBlock(startKey)
if (block && block.isVoid) {
return transform.removeNodeByKey(block.key, { normalize })
transform.removeNodeByKey(block.key, { normalize })
return
}
const inline = document.getClosestInline(startKey)
if (inline && inline.isVoid) {
return transform.removeNodeByKey(inline.key, { normalize })
transform.removeNodeByKey(inline.key, { normalize })
return
}
if (range.isAtEndOf(document)) {
return transform
return
}
const text = document.getDescendant(startKey)
@@ -219,11 +231,13 @@ export function deleteForwardAtRange(transform, range, n = 1, options = {}) {
const nextInline = document.getClosestInline(next.key)
if (nextBlock && nextBlock.isVoid) {
return transform.removeNodeByKey(nextBlock.key, { normalize })
transform.removeNodeByKey(nextBlock.key, { normalize })
return
}
if (nextInline && nextInline.isVoid) {
return transform.removeNodeByKey(nextInline.key, { normalize })
transform.removeNodeByKey(nextInline.key, { normalize })
return
}
range = range.merge({
@@ -231,14 +245,15 @@ export function deleteForwardAtRange(transform, range, n = 1, options = {}) {
focusOffset: 0
})
return transform.deleteAtRange(range, { normalize })
transform.deleteAtRange(range, { normalize })
return
}
range = range.merge({
focusOffset: focusOffset + n
})
return transform.deleteAtRange(range, { normalize })
transform.deleteAtRange(range, { normalize })
}
/**
@@ -249,7 +264,6 @@ export function deleteForwardAtRange(transform, range, n = 1, options = {}) {
* @param {Block|String|Object} block
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function insertBlockAtRange(transform, range, block, options = {}) {
@@ -295,8 +309,6 @@ export function insertBlockAtRange(transform, range, block, options = {}) {
if (normalize) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -307,7 +319,6 @@ export function insertBlockAtRange(transform, range, block, options = {}) {
* @param {Document} fragment
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function insertFragmentAtRange(transform, range, fragment, options = {}) {
@@ -315,14 +326,12 @@ export function insertFragmentAtRange(transform, range, fragment, options = {})
// If the range is expanded, delete it first.
if (range.isExpanded) {
transform.deleteAtRange(range, { normalize: false })
transform.deleteAtRange(range, OPTS)
range = range.collapseToStart()
}
// If the fragment is empty, there's nothing to do after deleting.
if (!fragment.length) {
return transform
}
if (!fragment.length) return
// Regenerate the keys for all of the fragments nodes, so that they're
// guaranteed not to collide with the existing keys in the document. Otherwise
@@ -358,13 +367,13 @@ export function insertFragmentAtRange(transform, range, fragment, options = {})
fragment.nodes.forEach((node, i) => {
const newIndex = startIndex + i + 1
transform.insertNodeByKey(parent.key, newIndex, node, { normalize: false })
transform.insertNodeByKey(parent.key, newIndex, node, OPTS)
})
}
// Check if we need to split the node.
if (startOffset != 0) {
transform.splitNodeByKey(startChild.key, offset, { normalize: false })
transform.splitNodeByKey(startChild.key, offset, OPTS)
}
// Update our variables with the new state.
@@ -384,15 +393,15 @@ export function insertFragmentAtRange(transform, range, fragment, options = {})
nextNodes.forEach((node, i) => {
const newIndex = lastIndex + i
transform.moveNodeByKey(node.key, lastBlock.key, newIndex, { normalize: false })
transform.moveNodeByKey(node.key, lastBlock.key, newIndex, OPTS)
})
}
// If the starting block is empty, we replace it entirely with the first block
// of the fragment, since this leads to a more expected behavior for the user.
if (startBlock.isEmpty) {
transform.removeNodeByKey(startBlock.key, { normalize: false })
transform.insertNodeByKey(parent.key, index, firstBlock, { normalize: false })
transform.removeNodeByKey(startBlock.key, OPTS)
transform.insertNodeByKey(parent.key, index, firstBlock, OPTS)
}
// Otherwise, we maintain the starting block, and insert all of the first
@@ -404,7 +413,7 @@ export function insertFragmentAtRange(transform, range, fragment, options = {})
firstBlock.nodes.forEach((inline, i) => {
const o = startOffset == 0 ? 0 : 1
const newIndex = inlineIndex + i + o
transform.insertNodeByKey(startBlock.key, newIndex, inline, { normalize: false })
transform.insertNodeByKey(startBlock.key, newIndex, inline, OPTS)
})
}
@@ -412,8 +421,6 @@ export function insertFragmentAtRange(transform, range, fragment, options = {})
if (normalize) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -424,7 +431,6 @@ export function insertFragmentAtRange(transform, range, fragment, options = {})
* @param {Inline|String|Object} inline
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function insertInlineAtRange(transform, range, inline, options = {}) {
@@ -432,7 +438,7 @@ export function insertInlineAtRange(transform, range, inline, options = {}) {
inline = Normalize.inline(inline)
if (range.isExpanded) {
transform.deleteAtRange(range, { normalize: false })
transform.deleteAtRange(range, OPTS)
range = range.collapseToStart()
}
@@ -443,18 +449,14 @@ export function insertInlineAtRange(transform, range, inline, options = {}) {
const startText = document.assertDescendant(startKey)
const index = parent.nodes.indexOf(startText)
if (parent.isVoid) {
return transform
}
if (parent.isVoid) return
transform.splitNodeByKey(startKey, startOffset, { normalize: false })
transform.insertNodeByKey(parent.key, index + 1, inline, { normalize: false })
transform.splitNodeByKey(startKey, startOffset, OPTS)
transform.insertNodeByKey(parent.key, index + 1, inline, OPTS)
if (normalize) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -466,7 +468,6 @@ export function insertInlineAtRange(transform, range, inline, options = {}) {
* @param {Set<Mark>} marks (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function insertTextAtRange(transform, range, text, marks, options = {}) {
@@ -476,12 +477,10 @@ export function insertTextAtRange(transform, range, text, marks, options = {}) {
const { startKey, startOffset } = range
const parent = document.getParent(startKey)
if (parent.isVoid) {
return transform
}
if (parent.isVoid) return
if (range.isExpanded) {
transform.deleteAtRange(range, { normalize: false })
transform.deleteAtRange(range, OPTS)
}
// PERF: Unless specified, don't normalize if only inserting text.
@@ -489,7 +488,7 @@ export function insertTextAtRange(transform, range, text, marks, options = {}) {
normalize = range.isExpanded
}
return transform.insertTextByKey(startKey, startOffset, text, marks, { normalize })
transform.insertTextByKey(startKey, startOffset, text, marks, { normalize })
}
/**
@@ -500,11 +499,10 @@ export function insertTextAtRange(transform, range, text, marks, options = {}) {
* @param {Mark|String} mark (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function removeMarkAtRange(transform, range, mark, options = {}) {
if (range.isCollapsed) return transform
if (range.isCollapsed) return
const { normalize = true } = options
const { state } = transform
@@ -523,8 +521,6 @@ export function removeMarkAtRange(transform, range, mark, options = {}) {
transform.removeMarkByKey(key, index, length, mark, { normalize })
})
return transform
}
/**
@@ -535,7 +531,6 @@ export function removeMarkAtRange(transform, range, mark, options = {}) {
* @param {Object|String} properties
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function setBlockAtRange(transform, range, properties, options = {}) {
@@ -547,8 +542,6 @@ export function setBlockAtRange(transform, range, properties, options = {}) {
blocks.forEach((block) => {
transform.setNodeByKey(block.key, properties, { normalize })
})
return transform
}
/**
@@ -559,7 +552,6 @@ export function setBlockAtRange(transform, range, properties, options = {}) {
* @param {Object|String} properties
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function setInlineAtRange(transform, range, properties, options = {}) {
@@ -571,8 +563,6 @@ export function setInlineAtRange(transform, range, properties, options = {}) {
inlines.forEach((inline) => {
transform.setNodeByKey(inline.key, properties, { normalize})
})
return transform
}
/**
@@ -583,7 +573,6 @@ export function setInlineAtRange(transform, range, properties, options = {}) {
* @param {Number} height (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function splitBlockAtRange(transform, range, height = 1, options = {}) {
@@ -609,7 +598,7 @@ export function splitBlockAtRange(transform, range, height = 1, options = {}) {
h++
}
return transform.splitNodeByKey(node.key, offset, { normalize })
transform.splitNodeByKey(node.key, offset, { normalize })
}
/**
@@ -620,7 +609,6 @@ export function splitBlockAtRange(transform, range, height = 1, options = {}) {
* @param {Number} height (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function splitInlineAtRange(transform, range, height = Infinity, options = {}) {
@@ -646,7 +634,7 @@ export function splitInlineAtRange(transform, range, height = Infinity, options
h++
}
return transform.splitNodeByKey(node.key, offset, { normalize })
transform.splitNodeByKey(node.key, offset, { normalize })
}
/**
@@ -658,11 +646,10 @@ export function splitInlineAtRange(transform, range, height = Infinity, options
* @param {Mixed} mark
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function toggleMarkAtRange(transform, range, mark, options = {}) {
if (range.isCollapsed) return transform
if (range.isCollapsed) return
mark = Normalize.mark(mark)
@@ -677,8 +664,6 @@ export function toggleMarkAtRange(transform, range, mark, options = {}) {
} else {
transform.addMarkAtRange(range, mark, { normalize })
}
return transform
}
/**
@@ -689,7 +674,6 @@ export function toggleMarkAtRange(transform, range, mark, options = {}) {
* @param {String|Object} properties
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function unwrapBlockAtRange(transform, range, properties, options = {}) {
@@ -728,17 +712,17 @@ export function unwrapBlockAtRange(transform, range, properties, options = {}) {
if (first == firstMatch && last == lastMatch) {
block.nodes.forEach((child, i) => {
transform.moveNodeByKey(child.key, parent.key, index + i, { normalize: false })
transform.moveNodeByKey(child.key, parent.key, index + i, OPTS)
})
transform.removeNodeByKey(block.key, { normalize: false })
transform.removeNodeByKey(block.key, OPTS)
}
else if (last == lastMatch) {
block.nodes
.skipUntil(n => n == firstMatch)
.forEach((child, i) => {
transform.moveNodeByKey(child.key, parent.key, index + 1 + i, { normalize: false })
transform.moveNodeByKey(child.key, parent.key, index + 1 + i, OPTS)
})
}
@@ -747,23 +731,23 @@ export function unwrapBlockAtRange(transform, range, properties, options = {}) {
.takeUntil(n => n == lastMatch)
.push(lastMatch)
.forEach((child, i) => {
transform.moveNodeByKey(child.key, parent.key, index + i, { normalize: false })
transform.moveNodeByKey(child.key, parent.key, index + i, OPTS)
})
}
else {
const offset = block.getOffset(firstMatch.key)
transform.splitNodeByKey(block.key, offset, { normalize: false })
transform.splitNodeByKey(block.key, offset, OPTS)
state = transform.state
document = state.document
const extra = document.getPreviousSibling(firstMatch.key)
children.forEach((child, i) => {
transform.moveNodeByKey(child.key, parent.key, index + 1 + i, { normalize: false })
transform.moveNodeByKey(child.key, parent.key, index + 1 + i, OPTS)
})
transform.removeNodeByKey(extra.key, { normalize: false })
transform.removeNodeByKey(extra.key, OPTS)
}
})
@@ -771,8 +755,6 @@ export function unwrapBlockAtRange(transform, range, properties, options = {}) {
if (normalize) {
transform.normalizeDocument(SCHEMA)
}
return transform
}
/**
@@ -783,7 +765,6 @@ export function unwrapBlockAtRange(transform, range, properties, options = {}) {
* @param {String|Object} properties
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function unwrapInlineAtRange(transform, range, properties, options = {}) {
@@ -812,7 +793,7 @@ export function unwrapInlineAtRange(transform, range, properties, options = {})
const index = parent.nodes.indexOf(inline)
inline.nodes.forEach((child, i) => {
transform.moveNodeByKey(child.key, parent.key, index + i, { normalize: false })
transform.moveNodeByKey(child.key, parent.key, index + i, OPTS)
})
})
@@ -820,8 +801,6 @@ export function unwrapInlineAtRange(transform, range, properties, options = {})
if (normalize) {
transform.normalizeDocument(SCHEMA)
}
return transform
}
/**
@@ -832,7 +811,6 @@ export function unwrapInlineAtRange(transform, range, properties, options = {})
* @param {Block|Object|String} block
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function wrapBlockAtRange(transform, range, block, options = {}) {
@@ -882,18 +860,16 @@ export function wrapBlockAtRange(transform, range, block, options = {}) {
}
// inject the new block node into the parent
transform.insertNodeByKey(parent.key, index, block, { normalize: false })
transform.insertNodeByKey(parent.key, index, block, OPTS)
// move the sibling nodes into the new block node
siblings.forEach((node, i) => {
transform.moveNodeByKey(node.key, block.key, i, { normalize: false })
transform.moveNodeByKey(node.key, block.key, i, OPTS)
})
if (normalize) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -904,11 +880,10 @@ export function wrapBlockAtRange(transform, range, block, options = {}) {
* @param {Inline|Object|String} inline
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function wrapInlineAtRange(transform, range, inline, options = {}) {
if (range.isCollapsed) return transform
if (range.isCollapsed) return
inline = Normalize.inline(inline)
inline = inline.merge({ nodes: inline.nodes.clear() })
@@ -935,11 +910,11 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
if (startBlock == endBlock) {
if (endOff != endChild.length) {
transform.splitNodeByKey(endChild.key, endOff, { normalize: false })
transform.splitNodeByKey(endChild.key, endOff, OPTS)
}
if (startOff != 0) {
transform.splitNodeByKey(startChild.key, startOff, { normalize: false })
transform.splitNodeByKey(startChild.key, startOff, OPTS)
}
state = transform.state
@@ -961,10 +936,10 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
const node = inline.regenerateKey()
transform.insertNodeByKey(startBlock.key, startInnerIndex, node, { normalize: false })
transform.insertNodeByKey(startBlock.key, startInnerIndex, node, OPTS)
inlines.forEach((child, i) => {
transform.moveNodeByKey(child.key, node.key, i, { normalize: false })
transform.moveNodeByKey(child.key, node.key, i, OPTS)
})
if (normalize) {
@@ -973,8 +948,8 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
}
else {
transform.splitNodeByKey(startChild.key, startOff, { normalize: false })
transform.splitNodeByKey(endChild.key, endOff, { normalize: false })
transform.splitNodeByKey(startChild.key, startOff, OPTS)
transform.splitNodeByKey(endChild.key, endOff, OPTS)
state = transform.state
document = state.document
@@ -986,15 +961,15 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
const startNode = inline.regenerateKey()
const endNode = inline.regenerateKey()
transform.insertNodeByKey(startBlock.key, startIndex - 1, startNode, { normalize: false })
transform.insertNodeByKey(endBlock.key, endIndex, endNode, { normalize: false })
transform.insertNodeByKey(startBlock.key, startIndex - 1, startNode, OPTS)
transform.insertNodeByKey(endBlock.key, endIndex, endNode, OPTS)
startInlines.forEach((child, i) => {
transform.moveNodeByKey(child.key, startNode.key, i, { normalize: false })
transform.moveNodeByKey(child.key, startNode.key, i, OPTS)
})
endInlines.forEach((child, i) => {
transform.moveNodeByKey(child.key, endNode.key, i, { normalize: false })
transform.moveNodeByKey(child.key, endNode.key, i, OPTS)
})
if (normalize) {
@@ -1005,10 +980,10 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
blocks.slice(1, -1).forEach((block) => {
const node = inline.regenerateKey()
transform.insertNodeByKey(block.key, 0, node, { normalize: false })
transform.insertNodeByKey(block.key, 0, node, OPTS)
block.nodes.forEach((child, i) => {
transform.moveNodeByKey(child.key, node.key, i, { normalize: false })
transform.moveNodeByKey(child.key, node.key, i, OPTS)
})
if (normalize) {
@@ -1016,8 +991,6 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
}
})
}
return transform
}
/**
@@ -1029,7 +1002,6 @@ export function wrapInlineAtRange(transform, range, inline, options = {}) {
* @param {String} suffix (optional)
* @param {Object} options
* @property {Boolean} normalize
* @return {Transform}
*/
export function wrapTextAtRange(transform, range, prefix, suffix = prefix, options = {}) {
@@ -1042,7 +1014,6 @@ export function wrapTextAtRange(transform, range, prefix, suffix = prefix, optio
end = end.moveForward(prefix.length)
}
return transform
.insertTextAtRange(start, prefix, [], { normalize })
.insertTextAtRange(end, suffix, [], { normalize })
transform.insertTextAtRange(start, prefix, [], { normalize })
transform.insertTextAtRange(end, suffix, [], { normalize })
}

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

@@ -11,8 +11,7 @@ import SCHEMA from '../schemas/core'
* @param {Number} length
* @param {Mixed} mark
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function addMarkByKey(transform, key, offset, length, mark, options = {}) {
@@ -28,8 +27,6 @@ export function addMarkByKey(transform, key, offset, length, mark, options = {})
const parent = document.getParent(key)
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -40,8 +37,7 @@ export function addMarkByKey(transform, key, offset, length, mark, options = {})
* @param {Number} index
* @param {Node} node
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function insertNodeByKey(transform, key, index, node, options = {}) {
@@ -55,8 +51,6 @@ export function insertNodeByKey(transform, key, index, node, options = {}) {
if (normalize) {
transform.normalizeNodeByKey(key, SCHEMA)
}
return transform
}
/**
@@ -68,8 +62,7 @@ export function insertNodeByKey(transform, key, index, node, options = {}) {
* @param {String} text
* @param {Set<Mark>} marks (optional)
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function insertTextByKey(transform, key, offset, text, marks, options = {}) {
@@ -84,8 +77,6 @@ export function insertTextByKey(transform, key, offset, text, marks, options = {
const parent = document.getParent(key)
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -95,8 +86,7 @@ export function insertTextByKey(transform, key, offset, text, marks, options = {
* @param {String} key
* @param {String} withKey
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function joinNodeByKey(transform, key, withKey, options = {}) {
@@ -110,14 +100,8 @@ export function joinNodeByKey(transform, key, withKey, options = {}) {
if (normalize) {
const parent = document.getCommonAncestor(key, withKey)
if (parent) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
} else {
transform.normalizeDocument(SCHEMA)
}
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -129,8 +113,7 @@ export function joinNodeByKey(transform, key, withKey, options = {}) {
* @param {String} newKey
* @param {Number} index
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function moveNodeByKey(transform, key, newKey, newIndex, options = {}) {
@@ -143,11 +126,9 @@ export function moveNodeByKey(transform, key, newKey, newIndex, options = {}) {
transform.moveNodeOperation(path, newPath, newIndex)
if (normalize) {
const parent = document.key == newKey ? document : document.getCommonAncestor(key, newKey)
const parent = document.getCommonAncestor(key, newKey)
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -159,8 +140,7 @@ export function moveNodeByKey(transform, key, newKey, newIndex, options = {}) {
* @param {Number} length
* @param {Mark} mark
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function removeMarkByKey(transform, key, offset, length, mark, options = {}) {
@@ -176,8 +156,6 @@ export function removeMarkByKey(transform, key, offset, length, mark, options =
const parent = document.getParent(key)
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -186,8 +164,7 @@ export function removeMarkByKey(transform, key, offset, length, mark, options =
* @param {Transform} transform
* @param {String} key
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function removeNodeByKey(transform, key, options = {}) {
@@ -200,14 +177,8 @@ export function removeNodeByKey(transform, key, options = {}) {
if (normalize) {
const parent = document.getParent(key)
if (parent) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
} else {
transform.normalizeDocument(SCHEMA)
}
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -218,8 +189,7 @@ export function removeNodeByKey(transform, key, options = {}) {
* @param {Number} offset
* @param {Number} length
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function removeTextByKey(transform, key, offset, length, options = {}) {
@@ -231,11 +201,9 @@ export function removeTextByKey(transform, key, offset, length, options = {}) {
transform.removeTextOperation(path, offset, length)
if (normalize) {
const parent = document.getParent(key)
transform.normalizeParentsByKey(parent.key, SCHEMA)
const block = document.getClosestBlock(key)
transform.normalizeNodeByKey(block.key, SCHEMA)
}
return transform
}
/**
@@ -247,8 +215,7 @@ export function removeTextByKey(transform, key, offset, length, options = {}) {
* @param {Number} length
* @param {Mark} mark
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function setMarkByKey(transform, key, offset, length, mark, properties, options = {}) {
@@ -266,8 +233,6 @@ export function setMarkByKey(transform, key, offset, length, mark, properties, o
const parent = document.getParent(key)
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -277,8 +242,7 @@ export function setMarkByKey(transform, key, offset, length, mark, properties, o
* @param {String} key
* @param {Object|String} properties
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function setNodeByKey(transform, key, properties, options = {}) {
@@ -292,14 +256,8 @@ export function setNodeByKey(transform, key, properties, options = {}) {
if (normalize) {
const parent = document.getParent(key)
if (parent) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
} else {
transform.normalizeDocument(SCHEMA)
}
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -309,8 +267,7 @@ export function setNodeByKey(transform, key, properties, options = {}) {
* @param {String} key
* @param {Number} offset
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function splitNodeByKey(transform, key, offset, options = {}) {
@@ -323,14 +280,8 @@ export function splitNodeByKey(transform, key, offset, options = {}) {
if (normalize) {
const parent = document.getParent(key)
if (parent) {
transform.normalizeNodeByKey(parent.key, SCHEMA)
} else {
transform.normalizeDocument(SCHEMA)
}
transform.normalizeNodeByKey(parent.key, SCHEMA)
}
return transform
}
/**
@@ -340,16 +291,17 @@ export function splitNodeByKey(transform, key, offset, options = {}) {
* @param {String} key
* @param {Object|String} properties
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function unwrapInlineByKey(transform, key, properties, options) {
const { state } = transform
const { document, selection } = state
const node = document.assertDescendant(key)
const range = selection.moveToRangeOf(node.getFirstText(), node.getLastText())
return transform.unwrapInlineAtRange(range, properties, options)
const first = node.getFirstText()
const last = node.getLastText()
const range = selection.moveToRangeOf(first, last)
transform.unwrapInlineAtRange(range, properties, options)
}
/**
@@ -359,16 +311,17 @@ export function unwrapInlineByKey(transform, key, properties, options) {
* @param {String} key
* @param {Object|String} properties
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function unwrapBlockByKey(transform, key, properties, options) {
const { state } = transform
const { document, selection } = state
const node = document.assertDescendant(key)
const range = selection.moveToRangeOf(node.getFirstText(), node.getLastText())
return transform.unwrapBlockAtRange(range, properties, options)
const first = node.getFirstText()
const last = node.getLastText()
const range = selection.moveToRangeOf(first, last)
transform.unwrapBlockAtRange(range, properties, options)
}
/**
@@ -378,8 +331,7 @@ export function unwrapBlockByKey(transform, key, properties, options) {
* @param {String} key The node to wrap
* @param {Block|Object|String} block The wrapping block (its children are discarded)
* @param {Object} options
* @param {Boolean} normalize
* @return {Transform}
* @property {Boolean} normalize
*/
export function wrapBlockByKey(transform, key, block, options) {
@@ -391,7 +343,6 @@ export function wrapBlockByKey(transform, key, block, options) {
const parent = document.getParent(node.key)
const index = parent.nodes.indexOf(node)
return transform
.insertNodeByKey(parent.key, index, block, { normalize: false })
.moveNodeByKey(node.key, block.key, 0, options)
transform.insertNodeByKey(parent.key, index, block, { normalize: false })
transform.moveNodeByKey(node.key, block.key, 0, options)
}

10
src/transforms/index.js
View File

@@ -126,10 +126,14 @@ import {
focus,
moveBackward,
moveForward,
moveEndOffset,
moveStartOffset,
moveTo,
moveToOffsets,
moveToRangeOf,
unsetMarks,
unsetSelection,
snapshotSelection,
} from './on-selection'
/**
@@ -151,7 +155,6 @@ import {
normalizeDocument,
normalizeSelection,
normalizeNodeByKey,
normalizeParentsByKey,
} from './normalize'
/**
@@ -278,10 +281,14 @@ export default {
focus,
moveBackward,
moveForward,
moveEndOffset,
moveStartOffset,
moveTo,
moveToOffsets,
moveToRangeOf,
unsetMarks,
unsetSelection,
snapshotSelection,
/**
* History.
@@ -299,5 +306,4 @@ export default {
normalizeDocument,
normalizeSelection,
normalizeNodeByKey,
normalizeParentsByKey,
}

134
src/transforms/normalize.js
View File

@@ -8,13 +8,11 @@ import warn from '../utils/warn'
*
* @param {Transform} transform
* @param {Schema} schema
* @return {Transform}
*/
export function normalize(transform, schema) {
transform.normalizeDocument(schema)
transform.normalizeSelection(schema)
return transform
}
/**
@@ -22,14 +20,12 @@ export function normalize(transform, schema) {
*
* @param {Transform} transform
* @param {Schema} schema
* @return {Transform}
*/
export function normalizeDocument(transform, schema) {
const { state } = transform
const { document } = state
transform.normalizeNodeByKey(document.key, schema)
return transform
}
/**
@@ -38,57 +34,26 @@ export function normalizeDocument(transform, schema) {
* @param {Transform} transform
* @param {Node|String} key
* @param {Schema} schema
* @return {Transform}
*/
export function normalizeNodeByKey(transform, key, schema) {
assertSchema(schema)
key = Normalize.key(key)
// If the schema has no validation rules, there's nothing to normalize.
if (!schema.hasValidators) {
return transform
}
if (!schema.hasValidators) return
key = Normalize.key(key)
const { state } = transform
const { document } = state
const node = document.assertNode(key)
normalizeNodeWith(transform, node, schema)
return transform
normalizeNodeAndChildren(transform, node, schema)
}
/**
* Normalize a `node` and its parents with a `schema`.
* Normalize the selection.
*
* @param {Transform} transform
* @param {Node|String} key
* @param {Schema} schema
* @return {Transform}
*/
export function normalizeParentsByKey(transform, key, schema) {
assertSchema(schema)
key = Normalize.key(key)
// If the schema has no validation rules, there's nothing to normalize.
if (!schema.hasValidators) {
return transform
}
const { state } = transform
const { document } = state
const node = document.assertNode(key)
normalizeParentsWith(transform, node, schema)
return transform
}
/**
* Normalize only the selection.
*
* @param {Transform} transform
* @return {Transform}
*/
export function normalizeSelection(transform) {
@@ -117,7 +82,6 @@ export function normalizeSelection(transform) {
state = state.merge({ selection })
transform.state = state
return transform
}
/**
@@ -126,58 +90,29 @@ export function normalizeSelection(transform) {
* @param {Transform} transform
* @param {Node} node
* @param {Schema} schema
* @return {Transform}
*/
function normalizeNodeWith(transform, node, schema) {
// For performance considerations, we will check if the transform was changed.
const opCount = transform.operations.length
function normalizeNodeAndChildren(transform, node, schema) {
// For performance considerations, we will check if the transform has actually
// added operations to the queue.
const count = transform.operations.length
// Iterate over its children.
normalizeChildrenWith(transform, node, schema)
if (node.kind != 'text') {
node.nodes.forEach((child) => {
normalizeNodeAndChildren(transform, child, schema)
})
}
// Re-find the node reference if necessary.
if (transform.operations.length != opCount) {
if (transform.operations.length != count) {
node = refindNode(transform, node)
}
// Now normalize the node itself if it still exists.
if (node) {
normalizeNodeOnly(transform, node, schema)
normalizeNode(transform, node, schema)
}
return transform
}
/**
* Normalize a `node` and its parents with a `schema`.
*
* @param {Transform} transform
* @param {Node} node
* @param {Schema} schema
* @return {Transform}
*/
function normalizeParentsWith(transform, node, schema) {
normalizeNodeOnly(transform, node, schema)
// Normalize went back up to the very top of the document.
if (node.kind == 'document') {
return transform
}
// Re-find the node first.
node = refindNode(transform, node)
if (!node) {
return transform
}
const { state } = transform
const { document } = state
const parent = document.getParent(node.key)
return normalizeParentsWith(transform, parent, schema)
}
/**
@@ -197,51 +132,30 @@ function refindNode(transform, node) {
: document.getDescendant(node.key)
}
/**
* Normalize the children of a `node` with a `schema`.
*
* @param {Transform} transform
* @param {Node} node
* @param {Schema} schema
* @return {Transform}
*/
function normalizeChildrenWith(transform, node, schema) {
if (node.kind == 'text') return transform
node.nodes.forEach((child) => {
normalizeNodeWith(transform, child, schema)
})
return transform
}
/**
* Normalize a `node` with a `schema`, but not its children.
*
* @param {Transform} transform
* @param {Node} node
* @param {Schema} schema
* @return {Transform}
*/
function normalizeNodeOnly(transform, node, schema) {
function normalizeNode(transform, node, schema) {
let max = schema.rules.length
let iterations = 0
function iterate(t, n) {
const failure = n.validate(schema)
if (!failure) return t
if (!failure) return
// Run the `normalize` function for the rule with the invalid value.
const { value, rule } = failure
// Rule the `normalize` function for the rule with the invalid value.
rule.normalize(t, n, value)
// Re-find the node reference, in case it was updated. If the node no longer
// exists, we're done for this branch.
n = refindNode(t, n)
if (!n) return t
if (!n) return
// Increment the iterations counter, and check to make sure that we haven't
// exceeded the max. Without this check, it's easy for the `validate` or
@@ -254,10 +168,10 @@ function normalizeNodeOnly(transform, node, schema) {
}
// Otherwise, iterate again.
return iterate(t, n)
iterate(t, n)
}
return iterate(transform, node)
iterate(transform, node)
}
/**
@@ -267,9 +181,9 @@ function normalizeNodeOnly(transform, node, schema) {
*/
function assertSchema(schema) {
if (schema instanceof Schema) return
if (schema == null) {
if (schema instanceof Schema) {
return
} else if (schema == null) {
throw new Error('You must pass a `schema` object.')
} else {
throw new Error(`You passed an invalid \`schema\` object: ${schema}.`)

12
src/transforms/on-history.js
View File

@@ -3,7 +3,6 @@
* Redo to the next state in the history.
*
* @param {Transform} transform
* @return {Transform}
*/
export function redo(transform) {
@@ -13,7 +12,7 @@ export function redo(transform) {
// If there's no next snapshot, abort.
let next = redos.peek()
if (!next) return transform
if (!next) return
// Shift the next state into the undo stack.
redos = redos.pop()
@@ -31,7 +30,6 @@ export function redo(transform) {
// Update the transform.
transform.state = state
return transform
}
/**
@@ -39,7 +37,6 @@ export function redo(transform) {
*
* @param {Transform} transform
* @param {Object} options
* @return {Transform}
*/
export function save(transform, options = {}) {
@@ -49,7 +46,7 @@ export function save(transform, options = {}) {
let { undos, redos } = history
// If there are no operations, abort.
if (!operations.length) return transform
if (!operations.length) return
// Create a new save point or merge the operations into the previous one.
if (merge) {
@@ -71,14 +68,12 @@ export function save(transform, options = {}) {
// Update the transform.
transform.state = state
return transform
}
/**
* Undo the previous operations in the history.
*
* @param {Transform} transform
* @return {Transform}
*/
export function undo(transform) {
@@ -88,7 +83,7 @@ export function undo(transform) {
// If there's no previous snapshot, abort.
let previous = undos.peek()
if (!previous) return transform
if (!previous) return
// Shift the previous operations into the redo stack.
undos = undos.pop()
@@ -108,5 +103,4 @@ export function undo(transform) {
// Update the transform.
transform.state = state
return transform
}

148
src/transforms/on-selection.js
View File

@@ -3,70 +3,65 @@
* Blur the selection.
*
* @param {Transform} transform
* @return {Transform}
*/
export function blur(transform) {
const { state } = transform
const { selection } = state
const sel = selection.blur()
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the focus point to the anchor point.
*
* @param {Transform} transform
* @return {Transform}
*/
export function collapseToAnchor(transform) {
const { state } = transform
const { selection } = state
const sel = selection.collapseToAnchor()
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the start point to the end point.
*
* @param {Transform} transform
* @return {Transform}
*/
export function collapseToEnd(transform) {
const { state } = transform
const { selection } = state
const sel = selection.collapseToEnd()
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the anchor point to the focus point.
*
* @param {Transform} transform
* @return {Transform}
*/
export function collapseToFocus(transform) {
const { state } = transform
const { selection } = state
const sel = selection.collapseToFocus()
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the end point to the start point.
*
* @param {Transform} transform
* @return {Transform}
*/
export function collapseToStart(transform) {
const { state } = transform
const { selection } = state
const sel = selection.collapseToStart()
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -74,21 +69,19 @@ export function collapseToStart(transform) {
*
* @param {Transform} transform
* @param {Node} node
* @return {Transform}
*/
export function collapseToEndOf(transform, node) {
const { state } = transform
const { selection } = state
const sel = selection.collapseToEndOf(node)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the end of the next block.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToEndOfNextBlock(transform) {
@@ -97,17 +90,16 @@ export function collapseToEndOfNextBlock(transform) {
const blocks = document.getBlocksAtRange(selection)
const last = blocks.last()
const next = document.getNextBlock(last)
if (!next) return transform
if (!next) return
const sel = selection.collapseToEndOf(next)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the end of the next text.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToEndOfNextText(transform) {
@@ -116,17 +108,16 @@ export function collapseToEndOfNextText(transform) {
const texts = document.getTextsAtRange(selection)
const last = texts.last()
const next = document.getNextText(last)
if (!next) return transform
if (!next) return
const sel = selection.collapseToEndOf(next)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the end of the previous block.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToEndOfPreviousBlock(transform) {
@@ -135,17 +126,16 @@ export function collapseToEndOfPreviousBlock(transform) {
const blocks = document.getBlocksAtRange(selection)
const first = blocks.first()
const previous = document.getPreviousBlock(first)
if (!previous) return transform
if (!previous) return
const sel = selection.collapseToEndOf(previous)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the end of the previous text.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToEndOfPreviousText(transform) {
@@ -154,10 +144,10 @@ export function collapseToEndOfPreviousText(transform) {
const texts = document.getTextsAtRange(selection)
const first = texts.first()
const previous = document.getPreviousText(first)
if (!previous) return transform
if (!previous) return
const sel = selection.collapseToEndOf(previous)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -165,21 +155,19 @@ export function collapseToEndOfPreviousText(transform) {
*
* @param {Transform} transform
* @param {Node} node
* @return {Transform}
*/
export function collapseToStartOf(transform, node) {
const { state } = transform
const { selection } = state
const sel = selection.collapseToStartOf(node)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the start of the next block.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToStartOfNextBlock(transform) {
@@ -188,17 +176,16 @@ export function collapseToStartOfNextBlock(transform) {
const blocks = document.getBlocksAtRange(selection)
const last = blocks.last()
const next = document.getNextBlock(last)
if (!next) return transform
if (!next) return
const sel = selection.collapseToStartOf(next)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the start of the next text.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToStartOfNextText(transform) {
@@ -207,17 +194,16 @@ export function collapseToStartOfNextText(transform) {
const texts = document.getTextsAtRange(selection)
const last = texts.last()
const next = document.getNextText(last)
if (!next) return transform
if (!next) return
const sel = selection.collapseToStartOf(next)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the start of the previous block.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToStartOfPreviousBlock(transform) {
@@ -226,17 +212,16 @@ export function collapseToStartOfPreviousBlock(transform) {
const blocks = document.getBlocksAtRange(selection)
const first = blocks.first()
const previous = document.getPreviousBlock(first)
if (!previous) return transform
if (!previous) return
const sel = selection.collapseToStartOf(previous)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the selection to the start of the previous text.
*
* @param {Transform} tansform
* @return {Transform}
*/
export function collapseToStartOfPreviousText(transform) {
@@ -245,10 +230,10 @@ export function collapseToStartOfPreviousText(transform) {
const texts = document.getTextsAtRange(selection)
const first = texts.first()
const previous = document.getPreviousText(first)
if (!previous) return transform
if (!previous) return
const sel = selection.collapseToStartOf(previous)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -256,14 +241,13 @@ export function collapseToStartOfPreviousText(transform) {
*
* @param {Transform} transform
* @param {Number} n (optional)
* @return {Transform}
*/
export function extendBackward(transform, n) {
const { state } = transform
const { document, selection } = state
const sel = selection.extendBackward(n).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -271,14 +255,13 @@ export function extendBackward(transform, n) {
*
* @param {Transform} transform
* @param {Number} n (optional)
* @return {Transform}
*/
export function extendForward(transform, n) {
const { state } = transform
const { document, selection } = state
const sel = selection.extendForward(n).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -286,14 +269,13 @@ export function extendForward(transform, n) {
*
* @param {Transform} transform
* @param {Node} node
* @return {Transform}
*/
export function extendToEndOf(transform, node) {
const { state } = transform
const { document, selection } = state
const sel = selection.extendToEndOf(node).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -301,28 +283,26 @@ export function extendToEndOf(transform, node) {
*
* @param {Transform} transform
* @param {Node} node
* @return {Transform}
*/
export function extendToStartOf(transform, node) {
const { state } = transform
const { document, selection } = state
const sel = selection.extendToStartOf(node).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Focus the selection.
*
* @param {Transform} transform
* @return {Transform}
*/
export function focus(transform) {
const { state } = transform
const { selection } = state
const sel = selection.focus()
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -330,14 +310,13 @@ export function focus(transform) {
*
* @param {Transform} transform
* @param {Number} n (optional)
* @return {Transform}
*/
export function moveBackward(transform, n) {
const { state } = transform
const { document, selection } = state
const sel = selection.moveBackward(n).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -345,14 +324,13 @@ export function moveBackward(transform, n) {
*
* @param {Transform} transform
* @param {Number} n (optional)
* @return {Transform}
*/
export function moveForward(transform, n) {
const { state } = transform
const { document, selection } = state
const sel = selection.moveForward(n).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
@@ -360,11 +338,10 @@ export function moveForward(transform, n) {
*
* @param {Transform} transform
* @param {Object} properties
* @return {Transform}
*/
export function moveTo(transform, properties) {
return transform.setSelectionOperation(properties)
transform.setSelectionOperation(properties)
}
/**
@@ -373,14 +350,13 @@ export function moveTo(transform, properties) {
* @param {Transform} transform
* @param {Number} anchor
* @param {Number} focus (optional)
* @return {Transform}
*/
export function moveToOffsets(transform, anchor, fokus) {
export function moveToOffsets(transform, anchor, _focus) {
const { state } = transform
const { selection } = state
const sel = selection.moveToOffsets(anchor, fokus)
return transform.setSelectionOperation(sel)
const sel = selection.moveToOffsets(anchor, _focus)
transform.setSelectionOperation(sel)
}
/**
@@ -389,25 +365,73 @@ export function moveToOffsets(transform, anchor, fokus) {
* @param {Transform} transform
* @param {Node} start
* @param {Node} end (optional)
* @return {Transform}
*/
export function moveToRangeOf(transform, start, end) {
const { state } = transform
const { document, selection } = state
const sel = selection.moveToRangeOf(start, end).normalize(document)
return transform.setSelectionOperation(sel)
transform.setSelectionOperation(sel)
}
/**
* Move the start offset by `n`.
*
* @param {Transform} transform
* @param {Number} n
*/
export function moveStartOffset(transform, n) {
const { state } = transform
const { document, selection } = state
const sel = selection.moveStartOffset(n).normalize(document)
transform.setSelectionOperation(sel)
}
/**
* Move the end offset by `n`.
*
* @param {Transform} transform
* @param {Number} n
*/
export function moveEndOffset(transform, n) {
const { state } = transform
const { document, selection } = state
const sel = selection.moveEndOffset(n).normalize(document)
transform.setSelectionOperation(sel)
}
/**
* Unset the selection's marks.
*
* @param {Transform} transform
*/
export function unsetMarks(transform) {
transform.setSelectionOperation({ marks: null })
}
/**
* Snapshot the current selection.
*
* @param {Transform} transform
*/
export function snapshotSelection(transform) {
const { state } = transform
const { selection } = state
transform.setSelectionOperation(selection, { snapshot: true })
}
/**
* Unset the selection, removing an association to a node.
*
* @param {Transform} transform
* @return {Transform}
*/
export function unsetSelection(transform) {
return transform.setSelectionOperation({
transform.setSelectionOperation({
anchorKey: null,
anchorOffset: 0,
focusKey: null,

40
src/transforms/operations.js
View File

@@ -9,7 +9,6 @@ import Normalize from '../utils/normalize'
* @param {Number} offset
* @param {Number} length
* @param {Mixed} mark
* @return {Transform}
*/
export function addMarkOperation(transform, path, offset, length, mark) {
@@ -30,7 +29,7 @@ export function addMarkOperation(transform, path, offset, length, mark) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -40,7 +39,6 @@ export function addMarkOperation(transform, path, offset, length, mark) {
* @param {Array} path
* @param {Number} index
* @param {Node} node
* @return {Transform}
*/
export function insertNodeOperation(transform, path, index, node) {
@@ -58,7 +56,7 @@ export function insertNodeOperation(transform, path, index, node) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -69,7 +67,6 @@ export function insertNodeOperation(transform, path, index, node) {
* @param {Number} offset
* @param {String} text
* @param {Set<Mark>} marks (optional)
* @return {Transform}
*/
export function insertTextOperation(transform, path, offset, text, marks) {
@@ -90,7 +87,7 @@ export function insertTextOperation(transform, path, offset, text, marks) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -99,7 +96,6 @@ export function insertTextOperation(transform, path, offset, text, marks) {
* @param {Transform} transform
* @param {Array} path
* @param {Array} withPath
* @return {Transform}
*/
export function joinNodeOperation(transform, path, withPath) {
@@ -134,7 +130,7 @@ export function joinNodeOperation(transform, path, withPath) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -144,7 +140,6 @@ export function joinNodeOperation(transform, path, withPath) {
* @param {Array} path
* @param {Array} newPath
* @param {Number} newIndex
* @return {Transform}
*/
export function moveNodeOperation(transform, path, newPath, newIndex) {
@@ -167,7 +162,7 @@ export function moveNodeOperation(transform, path, newPath, newIndex) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -178,7 +173,6 @@ export function moveNodeOperation(transform, path, newPath, newIndex) {
* @param {Number} offset
* @param {Number} length
* @param {Mark} mark
* @return {Transform}
*/
export function removeMarkOperation(transform, path, offset, length, mark) {
@@ -199,7 +193,7 @@ export function removeMarkOperation(transform, path, offset, length, mark) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -207,7 +201,6 @@ export function removeMarkOperation(transform, path, offset, length, mark) {
*
* @param {Transform} transform
* @param {Array} path
* @return {Transform}
*/
export function removeNodeOperation(transform, path) {
@@ -230,7 +223,7 @@ export function removeNodeOperation(transform, path) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -240,7 +233,6 @@ export function removeNodeOperation(transform, path) {
* @param {Array} path
* @param {Number} offset
* @param {Number} length
* @return {Transform}
*/
export function removeTextOperation(transform, path, offset, length) {
@@ -282,7 +274,7 @@ export function removeTextOperation(transform, path, offset, length) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -294,7 +286,6 @@ export function removeTextOperation(transform, path, offset, length) {
* @param {Number} length
* @param {Mark} mark
* @param {Mark} newMark
* @return {Transform}
*/
export function setMarkOperation(transform, path, offset, length, mark, newMark) {
@@ -317,7 +308,7 @@ export function setMarkOperation(transform, path, offset, length, mark, newMark)
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -326,7 +317,6 @@ export function setMarkOperation(transform, path, offset, length, mark, newMark)
* @param {Transform} transform
* @param {Array} path
* @param {Object} properties
* @return {Transform}
*/
export function setNodeOperation(transform, path, properties) {
@@ -352,7 +342,7 @@ export function setNodeOperation(transform, path, properties) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -360,10 +350,9 @@ export function setNodeOperation(transform, path, properties) {
*
* @param {Transform} transform
* @param {Mixed} selection
* @return {Transform}
*/
export function setSelectionOperation(transform, properties) {
export function setSelectionOperation(transform, properties, options = {}) {
properties = Normalize.selectionProperties(properties)
const { state } = transform
@@ -375,7 +364,7 @@ export function setSelectionOperation(transform, properties) {
// create a dictionary of the previous values for all of the properties that
// are being changed, for the inverse operation.
for (const k in properties) {
if (properties[k] == selection[k]) continue
if (!options.snapshot && properties[k] == selection[k]) continue
props[k] = properties[k]
prevProps[k] = selection[k]
}
@@ -432,7 +421,7 @@ export function setSelectionOperation(transform, properties) {
}
// Apply the operation.
return transform.applyOperation(operation)
transform.applyOperation(operation)
}
/**
@@ -441,7 +430,6 @@ export function setSelectionOperation(transform, properties) {
* @param {Transform} transform
* @param {Array} path
* @param {Number} offset
* @return {Transform}
*/
export function splitNodeOperation(transform, path, offset) {
@@ -462,5 +450,5 @@ export function splitNodeOperation(transform, path, offset) {
inverse,
}
return transform.applyOperation(operation)
transform.applyOperation(operation)
}