740 lines
21 KiB
JavaScript
740 lines
21 KiB
JavaScript
import * as error from 'lib0/error'
|
|
|
|
import {
|
|
getItemCleanStart,
|
|
createID,
|
|
getMovedCoords,
|
|
updateMarkerChanges,
|
|
getState,
|
|
ContentAny,
|
|
ContentBinary,
|
|
ContentType,
|
|
ContentDoc,
|
|
Doc,
|
|
compareIDs,
|
|
createRelativePosition,
|
|
RelativePosition, ID, AbstractContent, ContentMove, Transaction, Item, AbstractType // eslint-disable-line
|
|
} from '../internals.js'
|
|
import { compareRelativePositions } from './RelativePosition.js'
|
|
import * as array from 'lib0/array'
|
|
|
|
const lengthExceeded = error.create('Length exceeded!')
|
|
|
|
/**
|
|
* We keep the moved-stack across several transactions. Local or remote changes can invalidate
|
|
* "moved coords" on the moved-stack.
|
|
*
|
|
* The reason for this is that if assoc < 0, then getMovedCoords will return the target.right item.
|
|
* While the computed item is on the stack, it is possible that a user inserts something between target
|
|
* and the item on the stack. Then we expect that the newly inserted item is supposed to be on the new
|
|
* computed item.
|
|
*
|
|
* @param {Transaction} tr
|
|
* @param {ListCursor} li
|
|
*/
|
|
const popMovedStack = (tr, li) => {
|
|
let { start, end, move } = li.movedStack.pop() || { start: null, end: null, move: null }
|
|
if (move) {
|
|
const moveContent = /** @type {ContentMove} */ (move.content)
|
|
if (
|
|
(
|
|
moveContent.start.assoc < 0 && (
|
|
(start === null && moveContent.start.item !== null) ||
|
|
(start !== null && !compareIDs(/** @type {Item} */ (start.left).lastId, moveContent.start.item))
|
|
)
|
|
) || (
|
|
moveContent.end.assoc < 0 && (
|
|
(end === null && moveContent.end.item !== null) ||
|
|
(end !== null && !compareIDs(/** @type {Item} */ (end.left).lastId, moveContent.end.item))
|
|
)
|
|
)
|
|
) {
|
|
const coords = getMovedCoords(moveContent, tr, false)
|
|
start = coords.start
|
|
end = coords.end
|
|
}
|
|
}
|
|
li.currMove = move
|
|
li.currMoveStart = start
|
|
li.currMoveEnd = end
|
|
li.reachedEnd = false
|
|
}
|
|
|
|
/**
|
|
* Structure that helps to iterate through list-like structures. This is a useful abstraction that keeps track of move operations.
|
|
*/
|
|
export class ListCursor {
|
|
/**
|
|
* @param {AbstractType<any>} type
|
|
*/
|
|
constructor (type) {
|
|
this.type = type
|
|
/**
|
|
* Current index-position
|
|
*/
|
|
this.index = 0
|
|
/**
|
|
* Relative position to the current item (if item.content.length > 1)
|
|
*/
|
|
this.rel = 0
|
|
/**
|
|
* This refers to the current right item, unless reachedEnd is true. Then it refers to the left item.
|
|
*
|
|
* @public
|
|
* @type {Item | null}
|
|
*/
|
|
this.nextItem = type._start
|
|
this.reachedEnd = type._start === null
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
this.currMove = null
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
this.currMoveStart = null
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
this.currMoveEnd = null
|
|
/**
|
|
* @type {Array<{ start: Item | null, end: Item | null, move: Item }>}
|
|
*/
|
|
this.movedStack = []
|
|
}
|
|
|
|
clone () {
|
|
const iter = new ListCursor(this.type)
|
|
iter.index = this.index
|
|
iter.rel = this.rel
|
|
iter.nextItem = this.nextItem
|
|
iter.reachedEnd = this.reachedEnd
|
|
iter.currMove = this.currMove
|
|
iter.currMoveStart = this.currMoveStart
|
|
iter.currMoveEnd = this.currMoveEnd
|
|
iter.movedStack = this.movedStack.slice()
|
|
return iter
|
|
}
|
|
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
get left () {
|
|
if (this.reachedEnd) {
|
|
return this.nextItem
|
|
} else {
|
|
return this.nextItem && this.nextItem.left
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
get right () {
|
|
if (this.reachedEnd) {
|
|
return null
|
|
} else {
|
|
return this.nextItem
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {number} index
|
|
*/
|
|
moveTo (tr, index) {
|
|
const diff = index - this.index
|
|
if (diff > 0) {
|
|
this.forward(tr, diff, true)
|
|
} else if (diff < 0) {
|
|
this.backward(tr, -diff)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* When using skipUncountables=false within a "useSearchMarker" call, it is recommended
|
|
* to move the marker to the end. @todo do this after each useSearchMarkerCall
|
|
*
|
|
* @param {Transaction} tr
|
|
* @param {number} len
|
|
* @param {boolean} skipUncountables Iterate as much as possible iterating over uncountables until we find the next item.
|
|
*/
|
|
forward (tr, len, skipUncountables) {
|
|
if (len === 0 && this.nextItem == null) {
|
|
return this
|
|
}
|
|
if (this.index + len > this.type._length || this.nextItem == null) {
|
|
throw lengthExceeded
|
|
}
|
|
let item = /** @type {Item} */ (this.nextItem)
|
|
this.index += len
|
|
// eslint-disable-next-line no-unmodified-loop-condition
|
|
while ((!this.reachedEnd || this.currMove !== null) && (len > 0 || (skipUncountables && len === 0 && item && (!item.countable || item.deleted || item === this.currMoveEnd || (this.reachedEnd && this.currMoveEnd === null) || item.moved !== this.currMove)))) {
|
|
if (item === this.currMoveEnd || (this.currMoveEnd === null && this.reachedEnd && this.currMove)) {
|
|
item = /** @type {Item} */ (this.currMove) // we iterate to the right after the current condition
|
|
popMovedStack(tr, this)
|
|
} else if (item === null) {
|
|
error.unexpectedCase() // should never happen
|
|
} else if (item.countable && !item.deleted && item.moved === this.currMove && len > 0) {
|
|
len -= item.length
|
|
if (len < 0) {
|
|
this.rel = item.length + len
|
|
len = 0
|
|
break
|
|
}
|
|
} else if (item.content.constructor === ContentMove && item.moved === this.currMove) {
|
|
if (this.currMove) {
|
|
this.movedStack.push({ start: this.currMoveStart, end: this.currMoveEnd, move: this.currMove })
|
|
}
|
|
const { start, end } = getMovedCoords(item.content, tr, false)
|
|
this.currMove = item
|
|
this.currMoveStart = start
|
|
this.currMoveEnd = end
|
|
item = start
|
|
continue
|
|
}
|
|
if (this.reachedEnd) {
|
|
throw error.unexpectedCase
|
|
}
|
|
if (item.right) {
|
|
item = item.right
|
|
} else {
|
|
this.reachedEnd = true
|
|
}
|
|
}
|
|
this.index -= len
|
|
this.nextItem = item
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* We prefer to insert content outside of a moved range.
|
|
* Try to escape the moved range by walking to the left over deleted items.
|
|
*
|
|
* @param {Transaction} tr
|
|
*/
|
|
reduceMoveDepth (tr) {
|
|
let nextItem = this.nextItem
|
|
if (nextItem !== null) {
|
|
while (this.currMove) {
|
|
if (nextItem === this.currMoveStart) {
|
|
nextItem = /** @type {Item} */ (this.currMove) // we iterate to the left after the current condition
|
|
popMovedStack(tr, this)
|
|
continue
|
|
}
|
|
// check if we can iterate to the left while stepping over deleted items until we find an item === this.currMoveStart
|
|
/**
|
|
* @type {Item} nextItem
|
|
*/
|
|
let item = nextItem
|
|
while (item.deleted && item.moved === this.currMove && item !== this.currMoveStart) {
|
|
item = /** @type {Item} */ (item.left) // this must exist otherwise we miscalculated the move
|
|
}
|
|
if (item === this.currMoveStart) {
|
|
// we only want to iterate over deleted items if we can escape a move
|
|
nextItem = item
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
this.nextItem = nextItem
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {number} len
|
|
* @return {ListCursor}
|
|
*/
|
|
backward (tr, len) {
|
|
if (this.index - len < 0) {
|
|
throw lengthExceeded
|
|
}
|
|
this.index -= len
|
|
if (this.reachedEnd) {
|
|
const nextItem = /** @type {Item} */ (this.nextItem)
|
|
this.rel = nextItem.countable && !nextItem.deleted ? nextItem.length : 0
|
|
this.reachedEnd = false
|
|
}
|
|
if (this.rel >= len) {
|
|
this.rel -= len
|
|
return this
|
|
}
|
|
let item = this.nextItem
|
|
if (item && item.content.constructor === ContentMove) {
|
|
item = item.left
|
|
} else {
|
|
len += ((item && item.countable && !item.deleted && item.moved === this.currMove) ? item.length : 0) - this.rel
|
|
}
|
|
this.rel = 0
|
|
while (item && len > 0) {
|
|
if (item.countable && !item.deleted && item.moved === this.currMove) {
|
|
len -= item.length
|
|
if (len < 0) {
|
|
this.rel = -len
|
|
len = 0
|
|
}
|
|
if (len === 0) {
|
|
break
|
|
}
|
|
} else if (item.content.constructor === ContentMove && item.moved === this.currMove) {
|
|
if (this.currMove) {
|
|
this.movedStack.push({ start: this.currMoveStart, end: this.currMoveEnd, move: this.currMove })
|
|
}
|
|
const { start, end } = getMovedCoords(item.content, tr, false)
|
|
this.currMove = item
|
|
this.currMoveStart = start
|
|
this.currMoveEnd = end
|
|
item = start
|
|
continue
|
|
}
|
|
if (item === this.currMoveStart) {
|
|
item = /** @type {Item} */ (this.currMove) // we iterate to the left after the current condition
|
|
popMovedStack(tr, this)
|
|
}
|
|
item = item.left
|
|
}
|
|
this.nextItem = item
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* @template {{length: number}} T
|
|
* @param {Transaction} tr
|
|
* @param {number} len
|
|
* @param {T} value the initial content
|
|
* @param {function(AbstractContent, number, number):T} slice
|
|
* @param {function(T, T): T} concat
|
|
*/
|
|
_slice (tr, len, value, slice, concat) {
|
|
if (this.index + len > this.type._length) {
|
|
throw lengthExceeded
|
|
}
|
|
this.index += len
|
|
/**
|
|
* We store nextItem in a variable because this version cannot be null.
|
|
*/
|
|
let nextItem = /** @type {Item} */ (this.nextItem)
|
|
while (len > 0 && !this.reachedEnd) {
|
|
while (nextItem.countable && !this.reachedEnd && len > 0 && nextItem !== this.currMoveEnd) {
|
|
if (!nextItem.deleted && nextItem.moved === this.currMove) {
|
|
const slicedContent = slice(nextItem.content, this.rel, len)
|
|
len -= slicedContent.length
|
|
value = concat(value, slicedContent)
|
|
if (this.rel + slicedContent.length === nextItem.length) {
|
|
this.rel = 0
|
|
} else {
|
|
this.rel += slicedContent.length
|
|
continue // do not iterate to item.right
|
|
}
|
|
}
|
|
if (nextItem.right) {
|
|
nextItem = nextItem.right
|
|
} else {
|
|
this.reachedEnd = true
|
|
}
|
|
}
|
|
if ((!this.reachedEnd || this.currMove !== null) && len > 0) {
|
|
// always set nextItem before any method call
|
|
this.nextItem = nextItem
|
|
this.forward(tr, 0, true)
|
|
nextItem = this.nextItem
|
|
}
|
|
}
|
|
this.nextItem = nextItem
|
|
if (len < 0) {
|
|
this.index -= len
|
|
}
|
|
return value
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {number} len
|
|
*/
|
|
delete (tr, len) {
|
|
const startLength = len
|
|
const sm = this.type._searchMarker
|
|
let item = this.nextItem
|
|
if (this.index + len > this.type._length) {
|
|
throw lengthExceeded
|
|
}
|
|
while (len > 0) {
|
|
while (item && !item.deleted && item.countable && !this.reachedEnd && len > 0 && item.moved === this.currMove && item !== this.currMoveEnd) {
|
|
if (this.rel > 0) {
|
|
item = getItemCleanStart(tr, createID(item.id.client, item.id.clock + this.rel))
|
|
this.rel = 0
|
|
}
|
|
if (len < item.length) {
|
|
getItemCleanStart(tr, createID(item.id.client, item.id.clock + len))
|
|
}
|
|
len -= item.length
|
|
item.delete(tr)
|
|
if (item.right) {
|
|
item = item.right
|
|
} else {
|
|
this.reachedEnd = true
|
|
}
|
|
}
|
|
if (len > 0) {
|
|
this.nextItem = item
|
|
this.forward(tr, 0, true)
|
|
item = this.nextItem
|
|
}
|
|
}
|
|
this.nextItem = item
|
|
if (sm) {
|
|
updateMarkerChanges(sm, this.index, -startLength + len, this)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
*/
|
|
_splitRel (tr) {
|
|
if (this.rel > 0) {
|
|
/**
|
|
* @type {ID}
|
|
*/
|
|
const itemid = /** @type {Item} */ (this.nextItem).id
|
|
this.nextItem = getItemCleanStart(tr, createID(itemid.client, itemid.clock + this.rel))
|
|
this.rel = 0
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Important: you must update markers after calling this method!
|
|
*
|
|
* @param {Transaction} tr
|
|
* @param {Array<AbstractContent>} content
|
|
*/
|
|
insertContents (tr, content) {
|
|
this.reduceMoveDepth(tr)
|
|
this._splitRel(tr)
|
|
const parent = this.type
|
|
const store = tr.doc.store
|
|
const ownClientId = tr.doc.clientID
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
const right = this.right
|
|
|
|
/**
|
|
* @type {Item | null}
|
|
*/
|
|
let left = this.left
|
|
content.forEach(c => {
|
|
left = new Item(createID(ownClientId, getState(store, ownClientId)), left, left && left.lastId, right, right && right.id, parent, null, c)
|
|
left.integrate(tr, 0)
|
|
})
|
|
if (right === null) {
|
|
this.nextItem = left
|
|
this.reachedEnd = true
|
|
} else {
|
|
this.nextItem = right
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {Array<{ start: RelativePosition, end: RelativePosition }>} ranges
|
|
*/
|
|
insertMove (tr, ranges) {
|
|
this.insertContents(tr, ranges.map(range => new ContentMove(range.start, range.end, -1)))
|
|
// @todo is there a better alrogirthm to update searchmarkers? We could simply remove the markers that are in the updated range.
|
|
// Also note that searchmarkers are updated in insertContents as well.
|
|
const sm = this.type._searchMarker
|
|
if (sm) sm.length = 0 // @todo instead, iterate through sm and delete all marked properties on items
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {Array<Object<string,any>|Array<any>|boolean|number|null|string|Uint8Array>} values
|
|
*/
|
|
insertArrayValue (tr, values) {
|
|
this._splitRel(tr)
|
|
const sm = this.type._searchMarker
|
|
/**
|
|
* @type {Array<AbstractContent>}
|
|
*/
|
|
const contents = []
|
|
/**
|
|
* @type {Array<Object|Array<any>|number|null>}
|
|
*/
|
|
let jsonContent = []
|
|
const packJsonContent = () => {
|
|
if (jsonContent.length > 0) {
|
|
contents.push(new ContentAny(jsonContent))
|
|
jsonContent = []
|
|
}
|
|
}
|
|
values.forEach(c => {
|
|
if (c === null) {
|
|
jsonContent.push(c)
|
|
} else {
|
|
switch (c.constructor) {
|
|
case Number:
|
|
case Object:
|
|
case Boolean:
|
|
case Array:
|
|
case String:
|
|
jsonContent.push(c)
|
|
break
|
|
default:
|
|
packJsonContent()
|
|
switch (c.constructor) {
|
|
case Uint8Array:
|
|
case ArrayBuffer:
|
|
contents.push(new ContentBinary(new Uint8Array(/** @type {Uint8Array} */ (c))))
|
|
break
|
|
case Doc:
|
|
contents.push(new ContentDoc(/** @type {Doc} */ (c)))
|
|
break
|
|
default:
|
|
if (c instanceof AbstractType) {
|
|
contents.push(new ContentType(c))
|
|
} else {
|
|
throw new Error('Unexpected content type in insert operation')
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
packJsonContent()
|
|
this.insertContents(tr, contents)
|
|
this.index += values.length
|
|
if (sm) {
|
|
updateMarkerChanges(sm, this.index - values.length, values.length, this)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {number} len
|
|
*/
|
|
slice (tr, len) {
|
|
return this._slice(tr, len, [], sliceArrayContent, concatArrayContent)
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
* @param {function(any, number, any):void} f
|
|
*/
|
|
forEach (tr, f) {
|
|
for (const val of this.values(tr)) {
|
|
f(val, this.index, this.type)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @template T
|
|
* @param {Transaction} tr
|
|
* @param {function(any, number, any):T} f
|
|
* @return {Array<T>}
|
|
*/
|
|
map (tr, f) {
|
|
const arr = new Array(this.type._length - this.index)
|
|
let i = 0
|
|
for (const val of this.values(tr)) {
|
|
arr[i++] = f(val, this.index, this.type)
|
|
}
|
|
return arr
|
|
}
|
|
|
|
/**
|
|
* @param {Transaction} tr
|
|
*/
|
|
values (tr) {
|
|
return {
|
|
[Symbol.iterator] () {
|
|
return this
|
|
},
|
|
next: () => {
|
|
if (this.reachedEnd || this.index === this.type._length) {
|
|
return { done: true }
|
|
}
|
|
const [value] = this.slice(tr, 1)
|
|
return {
|
|
done: false,
|
|
value: value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {AbstractContent} itemcontent
|
|
* @param {number} start
|
|
* @param {number} len
|
|
*/
|
|
const sliceArrayContent = (itemcontent, start, len) => {
|
|
const content = itemcontent.getContent()
|
|
return content.length <= len && start === 0 ? content : content.slice(start, start + len)
|
|
}
|
|
/**
|
|
* @param {Array<any>} content
|
|
* @param {Array<any>} added
|
|
*/
|
|
const concatArrayContent = (content, added) => {
|
|
content.push(...added)
|
|
return content
|
|
}
|
|
|
|
/**
|
|
* Move-ranges must not cross each other.
|
|
*
|
|
* This function computes the minimal amount of ranges to move a range of content to
|
|
* a different place.
|
|
*
|
|
* Algorithm:
|
|
* * Store the current stack in $preStack and $preItem = walker.nextItem
|
|
* * Iterate forward $len items.
|
|
* * The current stack is stored is $afterStack and $
|
|
* * Delete the stack-items that both of them have in common
|
|
*
|
|
* @param {Transaction} tr
|
|
* @param {ListCursor} walker
|
|
* @param {number} len
|
|
* @return {Array<{ start: RelativePosition, end: RelativePosition }>}
|
|
*/
|
|
export const getMinimalListViewRanges = (tr, walker, len) => {
|
|
if (len === 0) return []
|
|
if (walker.index + len > walker.type._length) {
|
|
throw lengthExceeded
|
|
}
|
|
// stepping outside the current move-range as much as possible
|
|
walker.reduceMoveDepth(tr)
|
|
|
|
/**
|
|
* @type {Array<{ start: RelativePosition, end: RelativePosition, move: Item | null }>}
|
|
*/
|
|
const ranges = []
|
|
// store relevant information for the beginning, before we iterate forward
|
|
/**
|
|
* @type {Array<Item>}
|
|
*/
|
|
const preStack = walker.movedStack.map(si => si.move)
|
|
const preMove = walker.currMove
|
|
const preItem = /** @type {Item} */ (walker.nextItem)
|
|
const preRel = walker.rel
|
|
|
|
walker.forward(tr, len, false)
|
|
|
|
// store the same information for the end, after we iterate forward
|
|
/**
|
|
* @type {Array<Item>}
|
|
*/
|
|
const afterStack = walker.movedStack.map(si => si.move)
|
|
const afterMove = walker.currMove
|
|
/**
|
|
const nextIsCurrMoveStart = walker.nextItem === walker.currMoveStart
|
|
const afterItem = /** @type {Item} / (nextIsCurrMoveStart
|
|
? walker.currMove
|
|
: (walker.rel > 0 || walker.reachedEnd)
|
|
? walker.nextItem
|
|
: /** @type {Item} / (walker.nextItem).left
|
|
) */
|
|
const afterItem = /** @type {Item} */ (
|
|
(walker.rel > 0 || walker.reachedEnd)
|
|
? walker.nextItem
|
|
: /** @type {Item} */ (walker.nextItem).left
|
|
)
|
|
/**
|
|
* afterRel is always > 0
|
|
*/
|
|
const afterRel = walker.rel > 0
|
|
? walker.rel
|
|
: afterItem.length
|
|
|
|
walker.forward(tr, 0, false) // @todo remove once this is done is useSearchMarker
|
|
|
|
let start = createRelativePosition(walker.type, createID(preItem.id.client, preItem.id.clock + preRel), 0)
|
|
let end = createRelativePosition(
|
|
walker.type,
|
|
createID(afterItem.id.client, afterItem.id.clock + afterRel - 1),
|
|
-1
|
|
)
|
|
|
|
if (preMove) {
|
|
preStack.push(preMove)
|
|
}
|
|
if (afterMove) {
|
|
afterStack.push(afterMove)
|
|
}
|
|
|
|
// remove common stack-items
|
|
while (preStack.length > 0 && preStack[0] === afterStack[0]) {
|
|
preStack.shift()
|
|
afterStack.shift()
|
|
}
|
|
const topLevelMove = preStack.length > 0 ? preStack[0].moved : (afterStack.length > 0 ? afterStack[0].moved : null)
|
|
|
|
// remove stack-items that are useless for our computation (that wouldn't produce meaningful ranges)
|
|
// @todo
|
|
|
|
while (preStack.length > 0) {
|
|
const move = /** @type {Item} */ (preStack.pop())
|
|
ranges.push({
|
|
start,
|
|
end: /** @type {ContentMove} */ (move.content).end,
|
|
move
|
|
})
|
|
start = createRelativePosition(walker.type, createID(move.id.client, move.id.clock), -1)
|
|
}
|
|
|
|
const middleMove = { start, end, move: topLevelMove }
|
|
ranges.push(middleMove)
|
|
|
|
while (afterStack.length > 0) {
|
|
const move = /** @type {Item} */ (afterStack.pop())
|
|
ranges.push({
|
|
start: /** @type {ContentMove} */ (move.content).start,
|
|
end,
|
|
move
|
|
})
|
|
end = createRelativePosition(walker.type, createID(move.id.client, move.id.clock), 0)
|
|
}
|
|
|
|
// Update end of the center move operation
|
|
// Move ranges must be applied in order
|
|
middleMove.end = end
|
|
|
|
const normalizedRanges = array.flatten(ranges.map(range => {
|
|
// A subset of a range could be moved by another move with a higher priority.
|
|
// If that is the case, we need to ignore those moved items.
|
|
const { start, end } = getMovedCoords(range, tr, false)
|
|
const move = range.move
|
|
const ranges = []
|
|
/**
|
|
* @type {RelativePosition | null}
|
|
*/
|
|
let rangeStart = range.start
|
|
/**
|
|
* @type {Item}
|
|
*/
|
|
let item = start
|
|
while (item !== end) {
|
|
if (item.moved !== move && rangeStart != null) {
|
|
ranges.push({ start: rangeStart, end: createRelativePosition(walker.type, createID(item.id.client, item.id.clock), 0) })
|
|
rangeStart = null
|
|
}
|
|
if (item.moved === move && rangeStart === null) {
|
|
// @todo It might be better to set this to item.left, with assoc -1
|
|
rangeStart = createRelativePosition(walker.type, createID(item.id.client, item.id.clock), 0)
|
|
}
|
|
item = /** @type {Item} */ (item.right)
|
|
}
|
|
if (rangeStart != null) {
|
|
ranges.push({
|
|
start: rangeStart,
|
|
end: range.end
|
|
})
|
|
}
|
|
return ranges
|
|
}))
|
|
|
|
// filter out unnecessary ranges
|
|
return normalizedRanges.filter(range => !compareRelativePositions(range.start, range.end))
|
|
}
|