Przeglądaj źródła

Changed: added dash to the name of protected methods.

Szymon Cofalik 9 lat temu
rodzic
commit
9f5d3b0ee5

+ 3 - 3
packages/ckeditor5-engine/src/model/liveposition.js

@@ -155,7 +155,7 @@ function transform( type, range, position ) {
 	switch ( type ) {
 		case 'insert':
 			let insertBefore = this.stickiness == 'STICKS_TO_NEXT';
-			transformed = this.getTransformedByInsertion( range.start, howMany, insertBefore );
+			transformed = this._getTransformedByInsertion( range.start, howMany, insertBefore );
 			break;
 
 		case 'move':
@@ -167,12 +167,12 @@ function transform( type, range, position ) {
 				( originalRange.start.isEqual( this ) && this.stickiness == 'STICKS_TO_NEXT' ) ||
 				( originalRange.end.isEqual( this ) && this.stickiness == 'STICKS_TO_PREVIOUS' );
 
-			// We can't use .getTransformedByMove() because we have a different if-condition.
+			// We can't use ._getTransformedByMove() because we have a different if-condition.
 			if ( gotMoved ) {
 				transformed = this._getCombined( position, range.start );
 			} else {
 				let insertBefore = this.stickiness == 'STICKS_TO_NEXT';
-				transformed = this.getTransformedByMove( position, range.start, howMany, insertBefore );
+				transformed = this._getTransformedByMove( position, range.start, howMany, insertBefore );
 			}
 			break;
 		default:

+ 5 - 5
packages/ckeditor5-engine/src/model/liverange.js

@@ -113,7 +113,7 @@ function transform( type, range, position ) {
 
 	switch ( type ) {
 		case 'insert':
-			updated = this.getTransformedByInsertion( range.start, howMany, false, true )[ 0 ];
+			updated = this._getTransformedByInsertion( range.start, howMany, false, true )[ 0 ];
 			break;
 
 		case 'move':
@@ -121,12 +121,12 @@ function transform( type, range, position ) {
 		case 'reinsert':
 			const sourcePosition = position;
 
-			// Range.getTransformedByMove is expecting `targetPosition` to be "before" move
+			// Range._getTransformedByMove is expecting `targetPosition` to be "before" move
 			// (before transformation). `range.start` is already after the move happened.
 			// We have to revert `range.start` to the state before the move.
-			const targetPosition = range.start.getTransformedByInsertion( sourcePosition, howMany );
+			const targetPosition = range.start._getTransformedByInsertion( sourcePosition, howMany );
 
-			const result = this.getTransformedByMove( sourcePosition, targetPosition, howMany, false, true );
+			const result = this._getTransformedByMove( sourcePosition, targetPosition, howMany, false, true );
 
 			// First item in the array is the "difference" part, so a part of the range
 			// that did not get moved. We use it as reference range and expand if possible.
@@ -134,7 +134,7 @@ function transform( type, range, position ) {
 
 			// We will check if there is other range and if it is touching the reference range.
 			// If it does, we will expand the reference range (at the beginning or at the end).
-			// Keep in mind that without settings `spread` flag, `getTransformedByMove` may
+			// Keep in mind that without settings `spread` flag, `_getTransformedByMove` may
 			// return maximum two ranges.
 			if ( result.length > 1 ) {
 				let otherRange = result[ 1 ];

+ 2 - 2
packages/ckeditor5-engine/src/model/operation/moveoperation.js

@@ -65,7 +65,7 @@ export default class MoveOperation extends Operation {
 		 *
 		 * @member {engine.model.Position} engine.model.operation.MoveOperation#movedRangeStart
 		 */
-		this.movedRangeStart = this.targetPosition.getTransformedByDeletion( this.sourcePosition, this.howMany );
+		this.movedRangeStart = this.targetPosition._getTransformedByDeletion( this.sourcePosition, this.howMany );
 
 		/**
 		 * Defines whether `MoveOperation` is sticky. If `MoveOperation` is sticky, during
@@ -101,7 +101,7 @@ export default class MoveOperation extends Operation {
 	 * @returns {engine.model.operation.MoveOperation}
 	 */
 	getReversed() {
-		let newTargetPosition = this.sourcePosition.getTransformedByInsertion( this.targetPosition, this.howMany );
+		let newTargetPosition = this.sourcePosition._getTransformedByInsertion( this.targetPosition, this.howMany );
 
 		const op = new this.constructor( this.movedRangeStart, this.howMany, newTargetPosition, this.baseVersion + 1 );
 		op.isSticky = this.isSticky;

+ 13 - 13
packages/ckeditor5-engine/src/model/operation/transform.js

@@ -65,7 +65,7 @@ const ot = {
 			const transformed = a.clone();
 
 			// Transform insert position by the other operation position.
-			transformed.position = transformed.position.getTransformedByInsertion( b.position, b.nodes.totalOffset, !isStrong );
+			transformed.position = transformed.position._getTransformedByInsertion( b.position, b.nodes.totalOffset, !isStrong );
 
 			return [ transformed ];
 		},
@@ -80,7 +80,7 @@ const ot = {
 			const transformed = a.clone();
 
 			// Transform insert position by the other operation parameters.
-			transformed.position = a.position.getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !isStrong, b.isSticky );
+			transformed.position = a.position._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !isStrong, b.isSticky );
 
 			return [ transformed ];
 		}
@@ -90,7 +90,7 @@ const ot = {
 		// Transforms AttributeOperation `a` by InsertOperation `b`. Returns results as an array of operations.
 		InsertOperation( a, b ) {
 			// Transform this operation's range.
-			const ranges = a.range.getTransformedByInsertion( b.position, b.nodes.totalOffset, true, false );
+			const ranges = a.range._getTransformedByInsertion( b.position, b.nodes.totalOffset, true, false );
 
 			// Map transformed range(s) to operations and return them.
 			return ranges.reverse().map( ( range ) => {
@@ -169,15 +169,15 @@ const ot = {
 				// Take the start and the end of the range and transform them by deletion of moved nodes.
 				// Note that if rangeB was inside AttributeOperation range, only difference.end will be transformed.
 				// This nicely covers the joining simplification we did in the previous step.
-				difference.start = difference.start.getTransformedByDeletion( b.sourcePosition, b.howMany );
-				difference.end = difference.end.getTransformedByDeletion( b.sourcePosition, b.howMany );
+				difference.start = difference.start._getTransformedByDeletion( b.sourcePosition, b.howMany );
+				difference.end = difference.end._getTransformedByDeletion( b.sourcePosition, b.howMany );
 
 				// MoveOperation pastes nodes into target position. We acknowledge this by proper transformation.
 				// Note that since we operate on transformed difference range, we should transform by
 				// previously transformed target position.
-				// Note that we do not use Position.getTransformedByMove on range boundaries because we need to
+				// Note that we do not use Position._getTransformedByMove on range boundaries because we need to
 				// transform by insertion a range as a whole, since newTargetPosition might be inside that range.
-				ranges = difference.getTransformedByInsertion( b.movedRangeStart, b.howMany, true, false ).reverse();
+				ranges = difference._getTransformedByInsertion( b.movedRangeStart, b.howMany, true, false ).reverse();
 			}
 
 			if ( common !== null ) {
@@ -223,14 +223,14 @@ const ot = {
 		InsertOperation( a, b, isStrong ) {
 			// Create range from MoveOperation properties and transform it by insertion.
 			let range = Range.createFromPositionAndShift( a.sourcePosition, a.howMany );
-			range = range.getTransformedByInsertion( b.position, b.nodes.totalOffset, false, a.isSticky )[ 0 ];
+			range = range._getTransformedByInsertion( b.position, b.nodes.totalOffset, false, a.isSticky )[ 0 ];
 
 			let result = new a.constructor(
 				range.start,
 				range.end.offset - range.start.offset,
 				a instanceof RemoveOperation ?
 					a.baseVersion :
-					a.targetPosition.getTransformedByInsertion( b.position, b.nodes.totalOffset, !isStrong ),
+					a.targetPosition._getTransformedByInsertion( b.position, b.nodes.totalOffset, !isStrong ),
 				a instanceof RemoveOperation ? undefined : a.baseVersion
 			);
 
@@ -289,8 +289,8 @@ const ot = {
 			let difference = joinRanges( rangeA.getDifference( rangeB ) );
 
 			if ( difference ) {
-				difference.start = difference.start.getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !a.isSticky, false );
-				difference.end = difference.end.getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, a.isSticky, false );
+				difference.start = difference.start._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, !a.isSticky, false );
+				difference.end = difference.end._getTransformedByMove( b.sourcePosition, b.targetPosition, b.howMany, a.isSticky, false );
 
 				ranges.push( difference );
 			}
@@ -344,7 +344,7 @@ const ot = {
 			}
 
 			// Target position also could be affected by the other MoveOperation. We will transform it.
-			let newTargetPosition = a.targetPosition.getTransformedByMove(
+			let newTargetPosition = a.targetPosition._getTransformedByMove(
 				b.sourcePosition,
 				b.targetPosition,
 				b.howMany,
@@ -424,7 +424,7 @@ function updateBaseVersions( baseVersion, operations ) {
 
 // Checks whether MoveOperation targetPosition is inside a node from the moved range of the other MoveOperation.
 function moveTargetIntoMovedRange( a, b ) {
-	return a.targetPosition.getTransformedByDeletion( b.sourcePosition, b.howMany ) === null;
+	return a.targetPosition._getTransformedByDeletion( b.sourcePosition, b.howMany ) === null;
 }
 
 // Gets an array of Ranges and produces one Range out of it. The root of a new range will be same as

+ 6 - 6
packages/ckeditor5-engine/src/model/position.js

@@ -386,7 +386,7 @@ export default class Position {
 	 * @param {Number} howMany How many nodes are removed.
 	 * @returns {engine.model.Position|null} Transformed position or `null`.
 	 */
-	getTransformedByDeletion( deletePosition, howMany ) {
+	_getTransformedByDeletion( deletePosition, howMany ) {
 		let transformed = Position.createFromPosition( this );
 
 		// This position can't be affected if deletion was in a different root.
@@ -437,7 +437,7 @@ export default class Position {
 	 * set to `true`, this position will get transformed. If the flag is set to `false`, it won't.
 	 * @returns {engine.model.Position} Transformed position.
 	 */
-	getTransformedByInsertion( insertPosition, howMany, insertBefore ) {
+	_getTransformedByInsertion( insertPosition, howMany, insertBefore ) {
 		let transformed = Position.createFromPosition( this );
 
 		// This position can't be affected if insertion was in a different root.
@@ -480,12 +480,12 @@ export default class Position {
 	 * with the moved range if it is equal to one of range's boundaries.
 	 * @returns {engine.model.Position} Transformed position.
 	 */
-	getTransformedByMove( sourcePosition, targetPosition, howMany, insertBefore, sticky ) {
+	_getTransformedByMove( sourcePosition, targetPosition, howMany, insertBefore, sticky ) {
 		// Moving a range removes nodes from their original position. We acknowledge this by proper transformation.
-		let transformed = this.getTransformedByDeletion( sourcePosition, howMany );
+		let transformed = this._getTransformedByDeletion( sourcePosition, howMany );
 
 		// Then we update target position, as it could be affected by nodes removal too.
-		targetPosition = targetPosition.getTransformedByDeletion( sourcePosition, howMany );
+		targetPosition = targetPosition._getTransformedByDeletion( sourcePosition, howMany );
 
 		if ( transformed === null || ( sticky && transformed.isEqual( sourcePosition ) ) ) {
 			// This position is inside moved range (or sticks to it).
@@ -494,7 +494,7 @@ export default class Position {
 		} else {
 			// This position is not inside a removed range.
 			// In next step, we simply reflect inserting `howMany` nodes, which might further affect the position.
-			transformed = transformed.getTransformedByInsertion( targetPosition, howMany, insertBefore );
+			transformed = transformed._getTransformedByInsertion( targetPosition, howMany, insertBefore );
 		}
 
 		return transformed;

+ 17 - 17
packages/ckeditor5-engine/src/model/range.js

@@ -378,22 +378,22 @@ export default class Range {
 	 * Examples:
 	 *
 	 *		let range = new Range( new Position( root, [ 2, 7 ] ), new Position( root, [ 4, 0, 1 ] ) );
-	 *		let transformed = range.getTransformedByInsertion( new Position( root, [ 1 ] ), 2 );
+	 *		let transformed = range._getTransformedByInsertion( new Position( root, [ 1 ] ), 2 );
 	 *		// transformed array has one range from [ 4, 7 ] to [ 6, 0, 1 ]
 	 *
-	 *		transformed = range.getTransformedByInsertion( new Position( root, [ 4, 0, 0 ] ), 4 );
+	 *		transformed = range._getTransformedByInsertion( new Position( root, [ 4, 0, 0 ] ), 4 );
 	 *		// transformed array has one range from [ 2, 7 ] to [ 4, 0, 5 ]
 	 *
-	 *		transformed = range.getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 4 );
+	 *		transformed = range._getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 4 );
 	 *		// transformed array has one range, which is equal to original range
 	 *
-	 *		transformed = range.getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 4, true );
+	 *		transformed = range._getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 4, true );
 	 *		// transformed array has two ranges: from [ 2, 7 ] to [ 3, 2 ] and from [ 3, 6 ] to [ 4, 0, 1 ]
 	 *
-	 *		transformed = range.getTransformedByInsertion( new Position( root, [ 4, 0, 1 ] ), 4, false, false );
+	 *		transformed = range._getTransformedByInsertion( new Position( root, [ 4, 0, 1 ] ), 4, false, false );
 	 *		// transformed array has one range which is equal to original range because insertion is after the range boundary
 	 *
-	 *		transformed = range.getTransformedByInsertion( new Position( root, [ 4, 0, 1 ] ), 4, false, true );
+	 *		transformed = range._getTransformedByInsertion( new Position( root, [ 4, 0, 1 ] ), 4, false, true );
 	 *		// transformed array has one range: from [ 2, 7 ] to [ 4, 0, 5 ] because range was expanded
 	 *
 	 * @protected
@@ -405,7 +405,7 @@ export default class Range {
 	 * range boundary. Defaults to `false`.
 	 * @returns {Array.<engine.model.Range>} Result of the transformation.
 	 */
-	getTransformedByInsertion( insertPosition, howMany, spread = false, isSticky = false ) {
+	_getTransformedByInsertion( insertPosition, howMany, spread = false, isSticky = false ) {
 		if ( spread && this.containsPosition( insertPosition ) ) {
 			// Range has to be spread. The first part is from original start to the spread point.
 			// The other part is from spread point to the original end, but transformed by
@@ -414,8 +414,8 @@ export default class Range {
 			return [
 				new Range( this.start, insertPosition ),
 				new Range(
-					insertPosition.getTransformedByInsertion( insertPosition, howMany, true ),
-					this.end.getTransformedByInsertion( insertPosition, howMany, this.isCollapsed )
+					insertPosition._getTransformedByInsertion( insertPosition, howMany, true ),
+					this.end._getTransformedByInsertion( insertPosition, howMany, this.isCollapsed )
 				)
 			];
 		} else {
@@ -424,8 +424,8 @@ export default class Range {
 			let insertBeforeStart = range.isCollapsed ? isSticky : !isSticky;
 			let insertBeforeEnd = isSticky;
 
-			range.start = range.start.getTransformedByInsertion( insertPosition, howMany, insertBeforeStart );
-			range.end = range.end.getTransformedByInsertion( insertPosition, howMany, insertBeforeEnd );
+			range.start = range.start._getTransformedByInsertion( insertPosition, howMany, insertBeforeStart );
+			range.end = range.end._getTransformedByInsertion( insertPosition, howMany, insertBeforeEnd );
 
 			return [ range ];
 		}
@@ -443,7 +443,7 @@ export default class Range {
 	 * was inside the range. Defaults to `false`.
 	 * @returns {Array.<engine.model.Range>} Result of the transformation.
 	 */
-	getTransformedByMove( sourcePosition, targetPosition, howMany, spread, isSticky = false ) {
+	_getTransformedByMove( sourcePosition, targetPosition, howMany, spread, isSticky = false ) {
 		let result;
 
 		const moveRange = new Range( sourcePosition, sourcePosition.getShiftedBy( howMany ) );
@@ -453,25 +453,25 @@ export default class Range {
 
 		if ( differenceSet.length == 1 ) {
 			difference = new Range(
-				differenceSet[ 0 ].start.getTransformedByDeletion( sourcePosition, howMany ),
-				differenceSet[ 0 ].end.getTransformedByDeletion( sourcePosition, howMany )
+				differenceSet[ 0 ].start._getTransformedByDeletion( sourcePosition, howMany ),
+				differenceSet[ 0 ].end._getTransformedByDeletion( sourcePosition, howMany )
 			);
 		} else if ( differenceSet.length == 2 ) {
 			// This means that ranges were moved from the inside of this range.
 			// So we can operate on this range positions and we don't have to transform starting position.
 			difference = new Range(
 				this.start,
-				this.end.getTransformedByDeletion( sourcePosition, howMany )
+				this.end._getTransformedByDeletion( sourcePosition, howMany )
 			);
 		} else {
 			// 0.
 			difference = null;
 		}
 
-		const insertPosition = targetPosition.getTransformedByDeletion( sourcePosition, howMany );
+		const insertPosition = targetPosition._getTransformedByDeletion( sourcePosition, howMany );
 
 		if ( difference ) {
-			result = difference.getTransformedByInsertion( insertPosition, howMany, spread, isSticky );
+			result = difference._getTransformedByInsertion( insertPosition, howMany, spread, isSticky );
 		} else {
 			result = [];
 		}

+ 1 - 1
packages/ckeditor5-engine/src/model/writer.js

@@ -123,7 +123,7 @@ export function move( sourceRange, targetPosition ) {
 
 	// We have to fix `targetPosition` because model changed after nodes from `sourceRange` got removed and
 	// that change might have an impact on `targetPosition`.
-	targetPosition = targetPosition.getTransformedByDeletion( sourceRange.start, sourceRange.end.offset - sourceRange.start.offset );
+	targetPosition = targetPosition._getTransformedByDeletion( sourceRange.start, sourceRange.end.offset - sourceRange.start.offset );
 
 	return this.insert( targetPosition, nodes );
 }

+ 24 - 24
packages/ckeditor5-engine/tests/model/position.js

@@ -496,10 +496,10 @@ describe( 'position', () => {
 		} );
 	} );
 
-	describe( 'getTransformedByInsertion', () => {
+	describe( '_getTransformedByInsertion', () => {
 		it( 'should return a new Position instance', () => {
 			const position = new Position( root, [ 0 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 2 ] ), 4, false );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 2 ] ), 4, false );
 
 			expect( transformed ).not.to.equal( position );
 			expect( transformed ).to.be.instanceof( Position );
@@ -507,58 +507,58 @@ describe( 'position', () => {
 
 		it( 'should increment offset if insertion is in the same parent and closer offset', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 1, 2, 2 ] ), 2, false );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 1, 2, 2 ] ), 2, false );
 
 			expect( transformed.offset ).to.equal( 5 );
 		} );
 
 		it( 'should not increment offset if insertion position is in different root', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( otherRoot, [ 1, 2, 2 ] ), 2, false );
+			const transformed = position._getTransformedByInsertion( new Position( otherRoot, [ 1, 2, 2 ] ), 2, false );
 
 			expect( transformed.offset ).to.equal( 3 );
 		} );
 
 		it( 'should not increment offset if insertion is in the same parent and the same offset', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 1, 2, 3 ] ), 2, false );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 1, 2, 3 ] ), 2, false );
 
 			expect( transformed.offset ).to.equal( 3 );
 		} );
 
 		it( 'should increment offset if insertion is in the same parent and the same offset and it is inserted before', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 1, 2, 3 ] ), 2, true );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 1, 2, 3 ] ), 2, true );
 
 			expect( transformed.offset ).to.equal( 5 );
 		} );
 
 		it( 'should not increment offset if insertion is in the same parent and further offset', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 1, 2, 4 ] ), 2, false );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 1, 2, 4 ] ), 2, false );
 
 			expect( transformed.offset ).to.equal( 3 );
 		} );
 
 		it( 'should update path if insertion position parent is a node from that path and offset is before next node on that path', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 1, 2 ] ), 2, false );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 1, 2 ] ), 2, false );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 4, 3 ] );
 		} );
 
 		it( 'should not update path if insertion position parent is a node from that path and offset is after next node on that path', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByInsertion( new Position( root, [ 1, 3 ] ), 2, false );
+			const transformed = position._getTransformedByInsertion( new Position( root, [ 1, 3 ] ), 2, false );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 2, 3 ] );
 		} );
 	} );
 
-	describe( 'getTransformedByDeletion', () => {
+	describe( '_getTransformedByDeletion', () => {
 		it( 'should return a new Position instance', () => {
 			const position = new Position( root, [ 0 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 2 ] ), 4 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 2 ] ), 4 );
 
 			expect( transformed ).not.to.equal( position );
 			expect( transformed ).to.be.instanceof( Position );
@@ -566,86 +566,86 @@ describe( 'position', () => {
 
 		it( 'should return null if original position is inside one of removed nodes', () => {
 			const position = new Position( root, [ 1, 2 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 0 ] ), 2 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 0 ] ), 2 );
 
 			expect( transformed ).to.be.null;
 		} );
 
 		it( 'should decrement offset if deletion is in the same parent and closer offset', () => {
 			const position = new Position( root, [ 1, 2, 7 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 1, 2, 2 ] ), 2 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 1, 2, 2 ] ), 2 );
 
 			expect( transformed.offset ).to.equal( 5 );
 		} );
 
 		it( 'should return null if original position is between removed nodes', () => {
 			const position = new Position( root, [ 1, 2, 4 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 1, 2, 3 ] ), 5 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 1, 2, 3 ] ), 5 );
 
 			expect( transformed ).to.be.null;
 		} );
 
 		it( 'should not decrement offset if deletion position is in different root', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByDeletion( new Position( otherRoot, [ 1, 2, 1 ] ), 2 );
+			const transformed = position._getTransformedByDeletion( new Position( otherRoot, [ 1, 2, 1 ] ), 2 );
 
 			expect( transformed.offset ).to.equal( 3 );
 		} );
 
 		it( 'should not decrement offset if deletion is in the same parent and further offset', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 1, 2, 4 ] ), 2 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 1, 2, 4 ] ), 2 );
 
 			expect( transformed.offset ).to.equal( 3 );
 		} );
 
 		it( 'should update path if deletion position parent is a node from that path and offset is before next node on that path', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 1, 0 ] ), 2 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 1, 0 ] ), 2 );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 0, 3 ] );
 		} );
 
 		it( 'should not update path if deletion position parent is a node from that path and offset is after next node on that path', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByDeletion( new Position( root, [ 1, 3 ] ), 2 );
+			const transformed = position._getTransformedByDeletion( new Position( root, [ 1, 3 ] ), 2 );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 2, 3 ] );
 		} );
 	} );
 
-	describe( 'getTransformedByMove', () => {
+	describe( '_getTransformedByMove', () => {
 		it( 'should increment offset if a range was moved to the same parent and closer offset', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByMove( new Position( root, [ 2 ] ), new Position( root, [ 1, 2, 0 ] ), 3, false );
+			const transformed = position._getTransformedByMove( new Position( root, [ 2 ] ), new Position( root, [ 1, 2, 0 ] ), 3, false );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 2, 6 ] );
 		} );
 
 		it( 'should decrement offset if a range was moved from the same parent and closer offset', () => {
 			const position = new Position( root, [ 1, 2, 6 ] );
-			const transformed = position.getTransformedByMove( new Position( root, [ 1, 2, 0 ] ), new Position( root, [ 2 ] ), 3, false );
+			const transformed = position._getTransformedByMove( new Position( root, [ 1, 2, 0 ] ), new Position( root, [ 2 ] ), 3, false );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 2, 3 ] );
 		} );
 
 		it( 'should decrement offset if position was at the end of a range and move was not sticky', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByMove( new Position( root, [ 1, 2, 0 ] ), new Position( root, [ 2 ] ), 3, false );
+			const transformed = position._getTransformedByMove( new Position( root, [ 1, 2, 0 ] ), new Position( root, [ 2 ] ), 3, false );
 
 			expect( transformed.path ).to.deep.equal( [ 1, 2, 0 ] );
 		} );
 
 		it( 'should update path if position was at the end of a range and move was sticky', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByMove( new Position( root, [ 1, 2, 0 ] ), new Position( root, [ 2 ] ), 3, false, true );
+			const transformed = position._getTransformedByMove( new Position( root, [ 1, 2, 0 ] ), new Position( root, [ 2 ] ), 3, false, true );
 
 			expect( transformed.path ).to.deep.equal( [ 5 ] );
 		} );
 
 		it( 'should update path if a range contained this position', () => {
 			const position = new Position( root, [ 1, 2, 3 ] );
-			const transformed = position.getTransformedByMove( new Position( root, [ 1, 1 ] ), new Position( root, [ 2, 1 ] ), 3, false );
+			const transformed = position._getTransformedByMove( new Position( root, [ 1, 1 ] ), new Position( root, [ 2, 1 ] ), 3, false );
 
 			expect( transformed.path ).to.deep.equal( [ 2, 2, 3 ] );
 		} );

+ 27 - 27
packages/ckeditor5-engine/tests/model/range.js

@@ -339,10 +339,10 @@ describe( 'Range', () => {
 		} );
 	} );
 
-	describe( 'getTransformedByInsertion', () => {
+	describe( '_getTransformedByInsertion', () => {
 		it( 'should return an array of Range objects', () => {
 			const range = new Range( new Position( root, [ 0 ] ), new Position( root, [ 1 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 2 ] ), 2 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 2 ] ), 2 );
 
 			expect( transformed ).to.be.instanceof( Array );
 			expect( transformed[ 0 ] ).to.be.instanceof( Range );
@@ -350,7 +350,7 @@ describe( 'Range', () => {
 
 		it( 'should update it\'s positions offsets if insertion is before range and they are affected', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 3, 1 ] ), 2 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 3, 1 ] ), 2 );
 
 			expect( transformed[ 0 ].start.offset ).to.equal( 4 );
 			expect( transformed[ 0 ].end.offset ).to.equal( 6 );
@@ -358,7 +358,7 @@ describe( 'Range', () => {
 
 		it( 'should update it\'s positions paths if insertion is before range and they are affected', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 0 ] ), 2 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 0 ] ), 2 );
 
 			expect( transformed[ 0 ].start.path[ 0 ] ).to.equal( 5 );
 			expect( transformed[ 0 ].end.path[ 0 ] ).to.equal( 6 );
@@ -366,7 +366,7 @@ describe( 'Range', () => {
 
 		it( 'should expand range if insertion was in the middle of range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 5, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 5, 0 ] ), 4 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 5, 0 ] ), 4 );
 
 			expect( transformed.length ).to.equal( 1 );
 
@@ -376,7 +376,7 @@ describe( 'Range', () => {
 
 		it( 'should return array with two ranges if insertion was in the middle of range and spread flag was set', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 5, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 4, 1, 6 ] ), 4, true );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 4, 1, 6 ] ), 4, true );
 
 			expect( transformed.length ).to.equal( 2 );
 
@@ -389,7 +389,7 @@ describe( 'Range', () => {
 
 		it( 'should not expand range if insertion is equal to start boundary of the range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 8 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 5 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 3, 11 ] );
@@ -397,7 +397,7 @@ describe( 'Range', () => {
 
 		it( 'should expand range if insertion is equal to start boundary of the range and sticky flag is set', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 8 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3, false, true );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3, false, true );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 3, 11 ] );
@@ -405,7 +405,7 @@ describe( 'Range', () => {
 
 		it( 'should not update positions if insertion is before range (but not equal to the start boundary)', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 8 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 3, 1 ] ), 3 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 3, 1 ] ), 3 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 5 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 3, 11 ] );
@@ -413,7 +413,7 @@ describe( 'Range', () => {
 
 		it( 'should not expand range if insertion is equal to end boundary of the range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 4, 4 ] ), 3 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 4, 4 ] ), 3 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 4, 4 ] );
@@ -421,7 +421,7 @@ describe( 'Range', () => {
 
 		it( 'should expand range if insertion is equal to end boundary of the range and sticky flag is set', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 4, 4 ] ), 3, false, true );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 4, 4 ] ), 3, false, true );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 4, 7 ] );
@@ -429,7 +429,7 @@ describe( 'Range', () => {
 
 		it( 'should not update positions if insertion is after range (but not equal to the end boundary)', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 4, 5 ] ), 3 );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 4, 5 ] ), 3 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 4, 4 ] );
@@ -437,7 +437,7 @@ describe( 'Range', () => {
 
 		it( 'should not change if the range is collapsed and isSticky is false', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 2 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3, false, false );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3, false, false );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 3, 2 ] );
@@ -445,17 +445,17 @@ describe( 'Range', () => {
 
 		it( 'should move after inserted nodes if the range is collapsed and isSticky is true', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 2 ] ) );
-			const transformed = range.getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3, false, true );
+			const transformed = range._getTransformedByInsertion( new Position( root, [ 3, 2 ] ), 3, false, true );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 5 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 3, 5 ] );
 		} );
 	} );
 
-	describe( 'getTransformedByMove', () => {
+	describe( '_getTransformedByMove', () => {
 		it( 'should return an array of Range objects', () => {
 			const range = new Range( new Position( root, [ 0 ] ), new Position( root, [ 1 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 2 ] ), new Position( root, [ 5 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 2 ] ), new Position( root, [ 5 ] ), 2 );
 
 			expect( transformed ).to.be.instanceof( Array );
 			expect( transformed[ 0 ] ).to.be.instanceof( Range );
@@ -463,7 +463,7 @@ describe( 'Range', () => {
 
 		it( 'should update it\'s positions offsets if target is before range and they are affected', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 8, 1 ] ), new Position( root, [ 3, 1 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 8, 1 ] ), new Position( root, [ 3, 1 ] ), 2 );
 
 			expect( transformed[ 0 ].start.offset ).to.equal( 4 );
 			expect( transformed[ 0 ].end.offset ).to.equal( 6 );
@@ -471,7 +471,7 @@ describe( 'Range', () => {
 
 		it( 'should update it\'s positions paths if target is before range and they are affected', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 8 ] ), new Position( root, [ 0 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 8 ] ), new Position( root, [ 0 ] ), 2 );
 
 			expect( transformed[ 0 ].start.path[ 0 ] ).to.equal( 5 );
 			expect( transformed[ 0 ].end.path[ 0 ] ).to.equal( 6 );
@@ -479,7 +479,7 @@ describe( 'Range', () => {
 
 		it( 'should expand range if target was in the middle of range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 5, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 8 ] ), new Position( root, [ 5, 0 ] ), 4 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 8 ] ), new Position( root, [ 5, 0 ] ), 4 );
 
 			expect( transformed.length ).to.equal( 1 );
 
@@ -489,7 +489,7 @@ describe( 'Range', () => {
 
 		it( 'should not expand range if insertion is equal to start boundary of the range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 8 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 8, 2 ] ), new Position( root, [ 3, 2 ] ), 3 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 8, 2 ] ), new Position( root, [ 3, 2 ] ), 3 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 5 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 3, 11 ] );
@@ -497,7 +497,7 @@ describe( 'Range', () => {
 
 		it( 'should not expand range if insertion is equal to end boundary of the range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 8, 4 ] ), new Position( root, [ 4, 4 ] ), 3 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 8, 4 ] ), new Position( root, [ 4, 4 ] ), 3 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 4, 4 ] );
@@ -505,7 +505,7 @@ describe( 'Range', () => {
 
 		it( 'should update it\'s positions offsets if source is before range and they are affected', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 3, 0 ] ), new Position( root, [ 8, 1 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 3, 0 ] ), new Position( root, [ 8, 1 ] ), 2 );
 
 			expect( transformed[ 0 ].start.offset ).to.equal( 0 );
 			expect( transformed[ 0 ].end.offset ).to.equal( 2 );
@@ -513,7 +513,7 @@ describe( 'Range', () => {
 
 		it( 'should update it\'s positions paths if source is before range and they are affected', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 4, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 0 ] ), new Position( root, [ 8 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 0 ] ), new Position( root, [ 8 ] ), 2 );
 
 			expect( transformed[ 0 ].start.path[ 0 ] ).to.equal( 1 );
 			expect( transformed[ 0 ].end.path[ 0 ] ).to.equal( 2 );
@@ -521,7 +521,7 @@ describe( 'Range', () => {
 
 		it( 'should shrink range if source was in the middle of range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 5, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 5, 0 ] ), new Position( root, [ 8 ] ), 4 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 5, 0 ] ), new Position( root, [ 8 ] ), 4 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 5, 0 ] );
@@ -529,7 +529,7 @@ describe( 'Range', () => {
 
 		it( 'should shrink range if source contained range start position', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 5, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 3, 1 ] ), new Position( root, [ 8 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 3, 1 ] ), new Position( root, [ 8 ] ), 2 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 1 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 5, 4 ] );
@@ -537,7 +537,7 @@ describe( 'Range', () => {
 
 		it( 'should shrink range if source contained range end position', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 5, 4 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 5, 3 ] ), new Position( root, [ 8 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 5, 3 ] ), new Position( root, [ 8 ] ), 2 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 3, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 5, 3 ] );
@@ -545,7 +545,7 @@ describe( 'Range', () => {
 
 		it( 'should move range if it was contained in moved range', () => {
 			const range = new Range( new Position( root, [ 3, 2 ] ), new Position( root, [ 3, 7 ] ) );
-			const transformed = range.getTransformedByMove( new Position( root, [ 3 ] ), new Position( root, [ 6 ] ), 2 );
+			const transformed = range._getTransformedByMove( new Position( root, [ 3 ] ), new Position( root, [ 6 ] ), 2 );
 
 			expect( transformed[ 0 ].start.path ).to.deep.equal( [ 4, 2 ] );
 			expect( transformed[ 0 ].end.path ).to.deep.equal( [ 4, 7 ] );