Function transformSets has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

export function transformSets( operationsA, operationsB, options ) {
    // Create new arrays so the originally passed arguments are not changed.
    // No need to clone operations, they are cloned as they are transformed.
    operationsA = operationsA.slice();
    operationsB = operationsB.slice();

• Read up
  Read up

Function _createAt has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    static _createAt( itemOrPosition, offset, stickiness = 'toNone' ) {
        if ( itemOrPosition instanceof Position ) {
            return new Position( itemOrPosition.root, itemOrPosition.path, itemOrPosition.stickiness );
        } else {
            const node = itemOrPosition;

• Read up
  Read up

Function split has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    split( position, limitElement ) {
        this._assertWriterUsedCorrectly();

        let splitElement = position.parent;

• Read up
  Read up

Function _getTransformedByMergeOperation has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    _getTransformedByMergeOperation( operation ) {
        // Special case when the marker is set on "the closing tag" of an element. Marker can be set like that during
        // transformations, especially when a content of a few block elements were removed. For example:
        //
        // {} is the transformed range, [] is the removed range.

• Read up
  Read up

Function _addOperationForAffectedMarkers has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    _addOperationForAffectedMarkers( type, positionOrRange ) {
        for ( const marker of this.model.markers ) {
            if ( !marker.managedUsingOperations ) {
                continue;
            }

• Read up
  Read up

Function checkMerge has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    checkMerge( positionOrBaseElement, elementToMerge = null ) {
        if ( positionOrBaseElement instanceof Position ) {
            const nodeBefore = positionOrBaseElement.nodeBefore;
            const nodeAfter = positionOrBaseElement.nodeAfter;

• Read up
  Read up

Function _processDataFromViewText has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    _processDataFromViewText( node ) {
        let data = node.data;

        // If any of node ancestors has a name which is in `preElements` array, then currently processed
        // view text node is (will be) in preformatted element. We should not change whitespaces then.

• Read up
  Read up

Function domSelectionToView has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    domSelectionToView( domSelection ) {
        // DOM selection might be placed in fake selection container.
        // If container contains fake selection - return corresponding view selection.
        if ( domSelection.rangeCount === 1 ) {
            let container = domSelection.getRangeAt( 0 ).startContainer;

• Read up
  Read up

Function attachDomRoot has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    attachDomRoot( domRoot, name = 'main' ) {
        const viewRoot = this.document.getRoot( name );

        // Set view root name the same as DOM root tag name.
        viewRoot._name = domRoot.tagName.toLowerCase();

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if ( !this.sameSelectionCharacters && item.textOffset !== 0 && item.textOffset !== text.length ) {
                            throw new Error( `Parse error - range delimiter '${ item.bracket }' is placed inside text node.` );
                        }

Function add has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    add( ...pattern ) {
        for ( let item of pattern ) {
            // String or RegExp pattern is used as element's name.
            if ( typeof item == 'string' || item instanceof RegExp ) {
                item = { name: item };

• Read up
  Read up

Function getModelLength has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    getModelLength( viewNode ) {
        if ( this._viewToModelLengthCallbacks.get( viewNode.name ) ) {
            const callback = this._viewToModelLengthCallbacks.get( viewNode.name );

            return callback( viewNode );

• Read up
  Read up

Function test has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    test( consumables ) {
        // Check if name can be consumed.
        if ( consumables.name && !this._canConsumeName ) {
            return this._canConsumeName;
        }

• Read up
  Read up

Function markerNameToElements has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    markerNameToElements( name ) {
        const boundElements = this._markerNameToElements.get( name );

        if ( !boundElements ) {
            return null;

• Read up
  Read up

Function _getTransformedByInsertion has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    _getTransformedByInsertion( insertPosition, howMany ) {
        const transformed = Position._createAt( this );

        // This position can't be affected if insertion was in a different root.
        if ( this.root != insertPosition.root ) {

• Read up
  Read up

Function convertChanges has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    convertChanges( differ, markers, writer ) {
        // Before the view is updated, remove markers which have changed.
        for ( const change of differ.getMarkersToRemove() ) {
            this.convertMarkerRemove( change.name, change.range, writer );
        }

• Read up
  Read up

Function transform has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

function transform( operation ) {
    // Transform the range by the operation. Join the result ranges if needed.
    const ranges = this.getTransformedByOperation( operation );
    const result = Range._createFromRanges( ranges );

• Read up
  Read up

Function _validate has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    _validate() {
        if ( !this.range.isFlat ) {
            /**
             * The range to change is not flat.
             *

• Read up
  Read up

Function _isInInsertedElement has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    _isInInsertedElement( element ) {
        const parent = element.parent;

        if ( !parent ) {
            return false;

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if ( incEnd > oldEnd ) {
                            // This case is similar to a case described when incoming change was insert and old change was attribute.
                            // See comment above.
                            //
                            // This time incoming change is attribute. We need to split incoming change in this case too.