mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-12-01 17:36:35 +00:00
7233ea8f1b
The EventEmitter API we inherited from Node.js and then bastardized was getting awkward and cumbersome. The number of uses of ve.bind was getting out of control, and removing events meant caching the bound method in a property. Many of the "features" of EventEmitter wasn't even being used, some causing overhead, others just causing bloat. This change cleans up how EventEmitter is used throughout the codebase. The new event emitter API includes: * emit - identical to the previous API, no longer throws an error if you emit error without a handler * once - identical to the previous API, still introduces a wrapper* on - compatible with the previous API but has some new features * off - identical to removeListener in the previous API * connect - very similar to addListenerMethods but doesn't wrap callbacks in closures anymore * disconnect - new, basically the opposite of addListenerMethods Another change that is made in this commit is mixing in rather than inheriting from EventEmitter. Finally, there are changes throughout the codebase anywhere connect/disconnect could be used. Change-Id: Ic3085d39172a8a719ce7f036690f673e59848d3a
536 lines
16 KiB
JavaScript
536 lines
16 KiB
JavaScript
/*!
|
|
* VisualEditor Document class.
|
|
*
|
|
* @copyright 2011-2013 VisualEditor Team and others; see AUTHORS.txt
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
*/
|
|
|
|
/**
|
|
* Generic document.
|
|
*
|
|
* @class
|
|
* @mixins ve.EventEmitter
|
|
*
|
|
* @constructor
|
|
* @param {ve.Node} model Model to observe
|
|
*/
|
|
ve.Document = function VeDocument( documentNode ) {
|
|
// Mixin constructors
|
|
ve.EventEmitter.call( this );
|
|
|
|
// Properties
|
|
this.documentNode = documentNode;
|
|
};
|
|
|
|
/* Inheritance */
|
|
|
|
ve.mixinClass( ve.Document, ve.EventEmitter );
|
|
|
|
/* Methods */
|
|
|
|
/**
|
|
* Get the root of the document's node tree.
|
|
*
|
|
* @method
|
|
* @returns {ve.Node} Root of node tree
|
|
*/
|
|
ve.Document.prototype.getDocumentNode = function () {
|
|
return this.documentNode;
|
|
};
|
|
|
|
/**
|
|
* Gets a list of nodes and the ranges within them that a selection of the document covers.
|
|
*
|
|
* @method
|
|
* @param {ve.Range} range Range within document to select nodes
|
|
* @param {string} [mode='leaves'] Type of selection to perform:
|
|
*
|
|
* - `leaves`: Return all leaf nodes in the given range (descends all the way down)
|
|
* - `branches`': Return all branch nodes in the given range
|
|
* - `covered`: Do not descend into nodes that are entirely covered by the range. The result
|
|
* is similar to that of 'leaves' except that if a node is entirely covered, its
|
|
* children aren't returned separately.
|
|
* - `siblings`: Return a set of adjacent siblings covered by the range (descends as long as the
|
|
* range is in a single node)
|
|
* @returns {Array} List of objects describing nodes in the selection and the ranges therein:
|
|
*
|
|
* - `node`: Reference to a ve.dm.Node
|
|
* - `range`: ve.Range, missing if the entire node is covered
|
|
* - `index`: Index of the node in its parent, missing if node has no parent
|
|
* - `indexInNode`: If range is a zero-length range between two children of node,
|
|
* this is set to the index of the child following range (or to
|
|
* `node.children.length + 1` if range is between the last child and
|
|
* the end). Missing in all other cases.
|
|
* - `nodeRange`: Range covering the inside of the entire node, not including wrapper
|
|
* - `nodeOuterRange`: Range covering the entire node, including wrapper
|
|
* - `parentOuterRange`: Outer range of node's parent. Missing if there is no parent
|
|
* or if indexInNode is set.
|
|
*
|
|
* @throws {Error} Range.start is out of range
|
|
* @throws {Error} Range.end is out of range
|
|
*/
|
|
ve.Document.prototype.selectNodes = function ( range, mode ) {
|
|
var doc = this.documentNode,
|
|
retval = [],
|
|
start = range.start,
|
|
end = range.end,
|
|
stack = [ {
|
|
// Node we are currently stepping through
|
|
// Note each iteration visits a child of node, not node itself
|
|
'node': doc,
|
|
// Index of the child in node we're visiting
|
|
'index': 0,
|
|
// First offset inside node
|
|
'startOffset': 0
|
|
} ],
|
|
node,
|
|
prevNode,
|
|
nextNode,
|
|
left,
|
|
right,
|
|
currentFrame = stack[0],
|
|
parentFrame,
|
|
startInside,
|
|
endInside,
|
|
startBetween,
|
|
endBetween,
|
|
startFound = false,
|
|
nodeRange,
|
|
parentRange,
|
|
isWrapped,
|
|
isPrevUnwrapped,
|
|
isNextUnwrapped;
|
|
|
|
mode = mode || 'leaves';
|
|
if ( mode !== 'leaves' && mode !== 'branches' && mode !== 'covered' && mode !== 'siblings' ) {
|
|
throw new Error( 'Invalid mode: ' + mode );
|
|
}
|
|
|
|
if ( start < 0 || start > doc.getLength() ) {
|
|
throw new Error( 'Invalid start offset: ' + start );
|
|
}
|
|
if ( end < 0 || end > doc.getLength() ) {
|
|
throw new Error( 'Invalid end offset: ' + end );
|
|
}
|
|
|
|
if ( !doc.children || doc.children.length === 0 ) {
|
|
// Document has no children. This is weird
|
|
nodeRange = new ve.Range( 0, doc.getLength() );
|
|
return [ {
|
|
'node': doc,
|
|
'range': new ve.Range( start, end ),
|
|
'index': 0,
|
|
'nodeRange': nodeRange,
|
|
'nodeOuterRange': nodeRange
|
|
} ];
|
|
}
|
|
left = doc.children[0].isWrapped() ? 1 : 0;
|
|
|
|
do {
|
|
node = currentFrame.node.children[currentFrame.index];
|
|
prevNode = currentFrame.node.children[currentFrame.index - 1];
|
|
nextNode = currentFrame.node.children[currentFrame.index + 1];
|
|
right = left + node.getLength();
|
|
// Is the start inside node?
|
|
startInside = start >= left && start <= right;
|
|
// Is the end inside node?
|
|
endInside = end >= left && end <= right;
|
|
// Does the node have wrapping elements around it
|
|
isWrapped = node.isWrapped();
|
|
// Is there an unwrapped node right before this node?
|
|
isPrevUnwrapped = prevNode ? !prevNode.isWrapped() : false;
|
|
// Is there an unwrapped node right after this node?
|
|
isNextUnwrapped = nextNode ? !nextNode.isWrapped() : false;
|
|
// Is the start between prevNode's closing and node or between the parent's opening and node?
|
|
startBetween = ( isWrapped ? start === left - 1 : start === left ) && !isPrevUnwrapped;
|
|
// Is the end between node and nextNode's opening or between node and the parent's closing?
|
|
endBetween = ( isWrapped ? end === right + 1 : end === right ) && !isNextUnwrapped;
|
|
parentRange = new ve.Range(
|
|
currentFrame.startOffset,
|
|
currentFrame.startOffset + currentFrame.node.getLength()
|
|
);
|
|
|
|
if ( isWrapped && end === left - 1 && currentFrame.index === 0 ) {
|
|
// The selection ends here with an empty range at the beginning of the node
|
|
// TODO duplicated code
|
|
isWrapped = currentFrame.node.isWrapped();
|
|
retval.push( {
|
|
'node': currentFrame.node,
|
|
'indexInNode': 0,
|
|
'range': new ve.Range( end, end ),
|
|
'nodeRange': parentRange,
|
|
'nodeOuterRange': new ve.Range(
|
|
parentRange.start - isWrapped, parentRange.end + isWrapped
|
|
)
|
|
} );
|
|
parentFrame = stack[stack.length - 2];
|
|
if ( parentFrame ) {
|
|
retval[retval.length - 1].index = parentFrame.index;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
if ( start === end && ( startBetween || endBetween ) && isWrapped ) {
|
|
// Empty range in the parent, outside of any child
|
|
isWrapped = currentFrame.node.isWrapped();
|
|
retval = [ {
|
|
'node': currentFrame.node,
|
|
'indexInNode': currentFrame.index + ( endBetween ? 1 : 0 ),
|
|
'range': new ve.Range( start, end ),
|
|
'nodeRange': parentRange,
|
|
'nodeOuterRange': new ve.Range(
|
|
parentRange.start - isWrapped, parentRange.end + isWrapped
|
|
)
|
|
} ];
|
|
parentFrame = stack[stack.length - 2];
|
|
if ( parentFrame ) {
|
|
retval[0].index = parentFrame.index;
|
|
}
|
|
return retval;
|
|
} else if ( startBetween ) {
|
|
// start is between the previous sibling and node
|
|
// so the selection covers all or part of node
|
|
|
|
// Descend if
|
|
// - we are in leaves mode, OR
|
|
// - we are in covered mode and the end is inside node OR
|
|
// - we are in branches mode and node is a branch (can have grandchildren)
|
|
if ( ( mode === 'leaves' ||
|
|
( mode === 'covered' && endInside ) ||
|
|
( mode === 'branches' && node.canHaveChildrenNotContent() ) ) &&
|
|
node.children && node.children.length
|
|
) {
|
|
// Descend into node
|
|
currentFrame = {
|
|
'node': node,
|
|
'index': 0,
|
|
'startOffset': left
|
|
};
|
|
stack.push( currentFrame );
|
|
startFound = true;
|
|
// If the first child of node has an opening, skip over it
|
|
if ( node.children[0].isWrapped() ) {
|
|
left++;
|
|
}
|
|
continue;
|
|
} else if ( !endInside ) {
|
|
// All of node is covered
|
|
retval.push( {
|
|
'node': node,
|
|
// no 'range' because the entire node is covered
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} );
|
|
startFound = true;
|
|
} else {
|
|
// Part of node is covered
|
|
return [ {
|
|
'node': node,
|
|
'range': new ve.Range( start, end ),
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} ];
|
|
}
|
|
} else if ( startInside && endInside ) {
|
|
if ( node.children && node.children.length &&
|
|
( mode !== 'branches' || node.canHaveChildrenNotContent() ) ) {
|
|
// Descend into node
|
|
currentFrame = {
|
|
'node': node,
|
|
'index': 0,
|
|
'startOffset': left
|
|
};
|
|
stack.push( currentFrame );
|
|
// If the first child of node has an opening, skip over it
|
|
if ( node.children[0].isWrapped() ) {
|
|
left++;
|
|
}
|
|
continue;
|
|
} else {
|
|
// node is a leaf node and the range is entirely inside it
|
|
return [ {
|
|
'node': node,
|
|
'range': new ve.Range( start, end ),
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} ];
|
|
}
|
|
} else if ( startInside ) {
|
|
if ( ( mode === 'leaves' ||
|
|
mode === 'covered' ||
|
|
( mode === 'branches' && node.canHaveChildrenNotContent() ) ) &&
|
|
node.children && node.children.length
|
|
) {
|
|
// node is a branch node and the start is inside it
|
|
// Descend into it
|
|
currentFrame = {
|
|
'node': node,
|
|
'index': 0,
|
|
'startOffset': left
|
|
};
|
|
stack.push( currentFrame );
|
|
// If the first child of node has an opening, skip over it
|
|
if ( node.children[0].isWrapped() ) {
|
|
left++;
|
|
}
|
|
continue;
|
|
} else {
|
|
// node is a leaf node and the start is inside it
|
|
// Add to retval and keep going
|
|
retval.push( {
|
|
'node': node,
|
|
'range': new ve.Range( start, right ),
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} );
|
|
startFound = true;
|
|
}
|
|
} else if ( endBetween ) {
|
|
// end is between node and the next sibling
|
|
// start is not inside node, so the selection covers
|
|
// all of node, then ends
|
|
|
|
if (
|
|
( mode === 'leaves' || ( mode === 'branches' && node.canHaveChildrenNotContent() ) ) &&
|
|
node.children && node.children.length
|
|
) {
|
|
// Descend into node
|
|
currentFrame = {
|
|
'node': node,
|
|
'index': 0,
|
|
'startOffset': left
|
|
};
|
|
stack.push( currentFrame );
|
|
// If the first child of node has an opening, skip over it
|
|
if ( node.children[0].isWrapped() ) {
|
|
left++;
|
|
}
|
|
continue;
|
|
} else {
|
|
// All of node is covered
|
|
retval.push( {
|
|
'node': node,
|
|
// no 'range' because the entire node is covered
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} );
|
|
return retval;
|
|
}
|
|
} else if ( endInside ) {
|
|
if ( ( mode === 'leaves' ||
|
|
mode === 'covered' ||
|
|
( mode === 'branches' && node.canHaveChildrenNotContent() ) ) &&
|
|
node.children && node.children.length
|
|
) {
|
|
// node is a branch node and the end is inside it
|
|
// Descend into it
|
|
currentFrame = {
|
|
'node': node,
|
|
'index': 0,
|
|
'startOffset': left
|
|
};
|
|
stack.push( currentFrame );
|
|
// If the first child of node has an opening, skip over it
|
|
if ( node.children[0].isWrapped() ) {
|
|
left++;
|
|
}
|
|
continue;
|
|
} else {
|
|
// node is a leaf node and the end is inside it
|
|
// Add to retval and return
|
|
retval.push( {
|
|
'node': node,
|
|
'range': new ve.Range( left, end ),
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} );
|
|
return retval;
|
|
}
|
|
} else if ( startFound && end > right ) {
|
|
// Neither the start nor the end is inside node, but we found the start earlier,
|
|
// so node must be between the start and the end
|
|
// Add the entire node, so no range property
|
|
|
|
if (
|
|
( mode === 'leaves' || ( mode === 'branches' && node.canHaveChildrenNotContent() ) ) &&
|
|
node.children && node.children.length
|
|
) {
|
|
// Descend into node
|
|
currentFrame = {
|
|
'node': node,
|
|
'index': 0,
|
|
'startOffset': left
|
|
};
|
|
stack.push( currentFrame );
|
|
// If the first child of node has an opening, skip over it
|
|
if ( node.children[0].isWrapped() ) {
|
|
left++;
|
|
}
|
|
continue;
|
|
} else {
|
|
// All of node is covered
|
|
retval.push( {
|
|
'node': node,
|
|
// no 'range' because the entire node is covered
|
|
'index': currentFrame.index,
|
|
'nodeRange': new ve.Range( left, right ),
|
|
'nodeOuterRange': new ve.Range( left - isWrapped, right + isWrapped ),
|
|
'parentOuterRange': new ve.Range(
|
|
parentRange.start - currentFrame.node.isWrapped(),
|
|
parentRange.end + currentFrame.node.isWrapped()
|
|
)
|
|
} );
|
|
}
|
|
}
|
|
|
|
// Move to the next node
|
|
if ( nextNode ) {
|
|
// The next node exists
|
|
// Advance the index; the start of the next iteration will essentially
|
|
// do node = nextNode;
|
|
currentFrame.index++;
|
|
// Advance to the first offset inside nextNode
|
|
left = right +
|
|
// Skip over node's closing, if present
|
|
( node.isWrapped() ? 1 : 0 ) +
|
|
// Skip over nextNode's opening, if present
|
|
( nextNode.isWrapped() ? 1 : 0 );
|
|
} else {
|
|
// There is no next node, move up the stack until there is one
|
|
left = right +
|
|
// Skip over node's closing, if present
|
|
( node.isWrapped() ? 1 : 0 );
|
|
while ( !nextNode ) {
|
|
// Check if the start is right past the end of this node, at the end of
|
|
// the parent
|
|
if ( node.isWrapped() && start === left ) {
|
|
// TODO duplicated code
|
|
parentRange = new ve.Range( currentFrame.startOffset,
|
|
currentFrame.startOffset + currentFrame.node.getLength()
|
|
);
|
|
isWrapped = currentFrame.node.isWrapped();
|
|
retval = [ {
|
|
'node': currentFrame.node,
|
|
'indexInNode': currentFrame.index + 1,
|
|
'range': new ve.Range( left, left ),
|
|
'nodeRange': parentRange,
|
|
'nodeOuterRange': new ve.Range(
|
|
parentRange.start - isWrapped, parentRange.end + isWrapped
|
|
)
|
|
} ];
|
|
parentFrame = stack[stack.length - 2];
|
|
if ( parentFrame ) {
|
|
retval[0].index = parentFrame.index;
|
|
}
|
|
}
|
|
|
|
// Move up the stack
|
|
stack.pop();
|
|
if ( stack.length === 0 ) {
|
|
// This shouldn't be possible
|
|
return retval;
|
|
}
|
|
currentFrame = stack[stack.length - 1];
|
|
currentFrame.index++;
|
|
nextNode = currentFrame.node.children[currentFrame.index];
|
|
// Skip over the parent node's closing
|
|
// (this is present for sure, because the parent has children)
|
|
left++;
|
|
}
|
|
|
|
// Skip over nextNode's opening if present
|
|
if ( nextNode.isWrapped() ) {
|
|
left++;
|
|
}
|
|
}
|
|
} while ( end >= left - 1 );
|
|
if ( retval.length === 0 ) {
|
|
throw new Error( 'selectNodes epic fail' );
|
|
}
|
|
return retval;
|
|
};
|
|
|
|
/**
|
|
* Get groups of sibling nodes covered by the given range.
|
|
*
|
|
* @param {ve.Range} selection Range
|
|
* @return {Array} Array of objects. Each object has the following keys:
|
|
* nodes: Array of sibling nodes covered by a part of range
|
|
* parent: Parent of all of these nodes
|
|
* grandparent: parent's parent
|
|
*/
|
|
ve.Document.prototype.getCoveredSiblingGroups = function ( selection ) {
|
|
var i, firstCoveredSibling, lastCoveredSibling, node, parentNode, siblingNode,
|
|
leaves = this.selectNodes( selection, 'leaves' ),
|
|
groups = [],
|
|
lastEndOffset = 0;
|
|
for ( i = 0; i < leaves.length; i++ ) {
|
|
if ( leaves[i].nodeOuterRange.end <= lastEndOffset ) {
|
|
// This range is contained within a range we've already processed
|
|
continue;
|
|
}
|
|
node = leaves[i].node;
|
|
// Traverse up to a content branch from content elements
|
|
if ( node.isContent() ) {
|
|
node = node.getParent();
|
|
}
|
|
parentNode = node.getParent();
|
|
// Group this with its covered siblings
|
|
groups.push( {
|
|
'parent': parentNode,
|
|
'grandparent': parentNode.getParent(),
|
|
'nodes': []
|
|
} );
|
|
firstCoveredSibling = node;
|
|
// Seek forward to the last covered sibling
|
|
siblingNode = firstCoveredSibling;
|
|
do {
|
|
// Add this to its sibling's group
|
|
groups[groups.length - 1].nodes.push( siblingNode );
|
|
lastCoveredSibling = siblingNode;
|
|
i++;
|
|
if ( leaves[i] === undefined ) {
|
|
break;
|
|
}
|
|
// Traverse up to a content branch from content elements
|
|
siblingNode = leaves[i].node;
|
|
if ( siblingNode.isContent() ) {
|
|
siblingNode = siblingNode.getParent();
|
|
}
|
|
} while ( siblingNode.getParent() === parentNode );
|
|
i--;
|
|
lastEndOffset = parentNode.getOuterRange().end;
|
|
}
|
|
return groups;
|
|
};
|