8
0
Piotr Jasiun 10 жил өмнө
parent
commit
13d71e9d42

+ 95 - 93
packages/ckeditor5-engine/src/treeview/element.js

@@ -5,136 +5,138 @@
 
 'use strict';
 
-CKEDITOR.define( [ 'utils', 'treeview/node', 'treeview/text', ], ( utils, Node, ViewText ) => {
-	class Element extends Node {
-		constructor( name, attrs, children ) {
-			/**
-			 * @readolny
-			 */
-			this.name = name;
-
-			if ( utils.isPlainObject( attrs ) ) {
-				this._attrs = utils.objectToMap( attrs );
-			} else {
-				this._attrs = new Map( attrs );
-			}
+import ViewText from './text.js';
+import Node from './node.js';
+import utils from '../utils.js';
 
-			this._children = utils.clone( children );
+export default class Element extends Node {
+	constructor( name, attrs, children ) {
+		/**
+		 * @readolny
+		 */
+		this.name = name;
 
-			this.domElement = null;
+		if ( utils.isPlainObject( attrs ) ) {
+			this._attrs = utils.objectToMap( attrs );
+		} else {
+			this._attrs = new Map( attrs );
 		}
 
-		setDomElement( domElement ) {
-			this.domElement = domElement;
+		this._children = utils.clone( children );
 
-			Element._domToViewMapping.set( domElement, this );
-		}
+		this.domElement = null;
+	}
 
-		// Note that created elements will not have coresponding DOM elements created it these did not exist before.
-		static createFromDom( domElement ) {
-			let viewElement = this.getCorespondingElement( domElement );
+	setDomElement( domElement ) {
+		this.domElement = domElement;
 
-			if ( viewElement ) {
-				return viewElement;
-			}
+		Element._domToViewMapping.set( domElement, this );
+	}
 
-			if ( domElement instanceof Text ) {
-				return new ViewText( domElement.data );
-			} else {
-				viewElement = new Element( domElement.name );
-				const attrs = domElement.attributes;
+	// Note that created elements will not have coresponding DOM elements created it these did not exist before.
+	static createFromDom( domElement ) {
+		let viewElement = this.getCorespondingElement( domElement );
 
-				for ( let i = attrs.length - 1; i >= 0; i-- ) {
-					viewElement.setAttr( attrs[ i ].name, attrs[ i ].value );
-				}
+		if ( viewElement ) {
+			return viewElement;
+		}
 
-				for ( let childView of viewElement.getChildren() ) {
-					domElement.appendChild( this.createFromDom( childView ) );
-				}
+		if ( domElement instanceof Text ) {
+			return new ViewText( domElement.data );
+		} else {
+			viewElement = new Element( domElement.name );
+			const attrs = domElement.attributes;
 
-				return domElement;
+			for ( let i = attrs.length - 1; i >= 0; i-- ) {
+				viewElement.setAttr( attrs[ i ].name, attrs[ i ].value );
 			}
-		}
 
-		// Coresponding elements exists only for rendered elementes.
-		static getCorespondingElement( domElement ) {
-			return this._domToViewMapping.get( domElement );
-		}
+			for ( let childView of viewElement.getChildren() ) {
+				domElement.appendChild( this.createFromDom( childView ) );
+			}
 
-		getChildren() {
-			return this._children[ Symbol.iterator ]();
+			return domElement;
 		}
+	}
 
-		getChild( index ) {
-			return this._children[ index ];
-		}
+	// Coresponding elements exists only for rendered elementes.
+	static getCorespondingElement( domElement ) {
+		return this._domToViewMapping.get( domElement );
+	}
 
-		getChildCount() {
-			return this._children.length;
-		}
+	getChildren() {
+		return this._children[ Symbol.iterator ]();
+	}
 
-		getChildIndex( node ) {
-			return this._children.indexOf( node );
-		}
+	getChild( index ) {
+		return this._children[ index ];
+	}
 
-		insertChildren( index, nodes ) {
-			this.markToSync( Node.CHILDREN_NEED_UPDATE );
+	getChildCount() {
+		return this._children.length;
+	}
 
-			if ( !utils.isIterable( nodes ) ) {
-				nodes = [ nodes ];
-			}
+	getChildIndex( node ) {
+		return this._children.indexOf( node );
+	}
 
-			for ( let node of nodes ) {
-				node.parent = this;
+	insertChildren( index, nodes ) {
+		this.markToSync( Node.CHILDREN_NEED_UPDATE );
 
-				this._children.splice( index, 0, node );
-			}
+		if ( !utils.isIterable( nodes ) ) {
+			nodes = [ nodes ];
 		}
 
-		removeChildren( index, number ) {
-			this.markToSync( Node.CHILDREN_NEED_UPDATE );
-
-			for ( let i = index; i < index + number; i++ ) {
-				this._children[ i ].parent = null;
-			}
+		for ( let node of nodes ) {
+			node.parent = this;
 
-			return new this._children.splice( index, number );
+			this._children.splice( index, 0, node );
 		}
+	}
 
-		getAttrKeys() {
-			return this._attrs.keys();
-		}
+	removeChildren( index, number ) {
+		this.markToSync( Node.CHILDREN_NEED_UPDATE );
 
-		getAttr( key ) {
-			return this._attrs.get( key );
+		for ( let i = index; i < index + number; i++ ) {
+			this._children[ i ].parent = null;
 		}
 
-		hasAttr( key ) {
-			return this._attrs.has( key );
-		}
+		return new this._children.splice( index, number );
+	}
 
-		setAttr( key, value ) {
-			this.markToSync( Node.ATTRIBUTES_NEED_UPDATE );
+	getAttrKeys() {
+		return this._attrs.keys();
+	}
 
-			this._attrs.set( key, value );
-		}
+	getAttr( key ) {
+		return this._attrs.get( key );
+	}
 
-		cloneDOMAttrs( element ) {
-			this.markToSync( Node.ATTRIBUTES_NEED_UPDATE );
+	hasAttr( key ) {
+		return this._attrs.has( key );
+	}
 
-			const attrKeys = element.attributes;
+	setAttr( key, value ) {
+		this.markToSync( Node.ATTRIBUTES_NEED_UPDATE );
 
-			for ( let key of attrKeys ) {
-				this.setAttr( key, element.getAttribute( key ) );
-			}
-		}
+		this._attrs.set( key, value );
+	}
 
-		removeAttr( key ) {
-			this.markToSync( Node.ATTRIBUTES_NEED_UPDATE );
+	cloneDOMAttrs( element ) {
+		this.markToSync( Node.ATTRIBUTES_NEED_UPDATE );
 
-			return this._attrs.delete( key );
+		const attrKeys = element.attributes;
+
+		for ( let key of attrKeys ) {
+			this.setAttr( key, element.getAttribute( key ) );
 		}
 	}
 
-	Element._domToViewMapping = new WeakMap();
-} );
+	removeAttr( key ) {
+		this.markToSync( Node.ATTRIBUTES_NEED_UPDATE );
+
+		return this._attrs.delete( key );
+	}
+}
+
+Element._domToViewMapping = new WeakMap();

+ 52 - 53
packages/ckeditor5-engine/src/treeview/node.js

@@ -5,73 +5,72 @@
 
 'use strict';
 
-CKEDITOR.define( [ 'treeview/Renderer', 'ckeditorerror' ], ( Renderer, CKEditorError ) => {
-	class Node {
-		constructor() {
-			this.parent = null;
-		}
-
-		getTreeView() {
-			if ( !this.parent ) {
-				return null;
-			} else {
-				return this.parent.getTreeView();
-			}
-		}
+import Renderer from './renderer.js';
+import CKEditorError from '../ckeditorerror.js';
 
-		getNextSibling() {
-			const index = this.getIndex();
+export default class Node {
+	constructor() {
+		this.parent = null;
+	}
 
-			return ( index !== null && this.parent.getChild( index + 1 ) ) || null;
+	getTreeView() {
+		if ( !this.parent ) {
+			return null;
+		} else {
+			return this.parent.getTreeView();
 		}
+	}
 
-		getPreviousSibling() {
-			const index = this.getIndex();
+	getNextSibling() {
+		const index = this.getIndex();
 
-			return ( index !== null && this.parent.getChild( index - 1 ) ) || null;
-		}
+		return ( index !== null && this.parent.getChild( index + 1 ) ) || null;
+	}
 
-		getIndex() {
-			let pos;
+	getPreviousSibling() {
+		const index = this.getIndex();
 
-			if ( !this.parent ) {
-				return null;
-			}
+		return ( index !== null && this.parent.getChild( index - 1 ) ) || null;
+	}
 
-			// No parent or child doesn't exist in parent's children.
-			if ( ( pos = this.parent.getChildIndex( this ) ) == -1 ) {
-				/**
-				 * The node's parent does not contain this node. It means that the document tree is corrupted.
-				 *
-				 * @error treeview-node-not-found-in-parent
-				 */
-				throw new CKEditorError( 'treeview-node-not-found-in-parent: The node\'s parent does not contain this node.' );
-			}
+	getIndex() {
+		let pos;
 
-			return pos;
+		if ( !this.parent ) {
+			return null;
 		}
 
-		markToSync( type ) {
-			// If the node has no DOM element it is not rendered yet, its children/attributes do not need to be marked to be sync.
-			if ( !this.DOMElement ) {
-				return;
-			}
+		// No parent or child doesn't exist in parent's children.
+		if ( ( pos = this.parent.getChildIndex( this ) ) == -1 ) {
+			/**
+			 * The node's parent does not contain this node. It means that the document tree is corrupted.
+			 *
+			 * @error treeview-node-not-found-in-parent
+			 */
+			throw new CKEditorError( 'treeview-node-not-found-in-parent: The node\'s parent does not contain this node.' );
+		}
 
-			const treeView = this.getTreeView();
+		return pos;
+	}
 
-			// If element is not attached to the Tree view it is a child of the detached subtree and will be rendered anyway with this
-			// subtree.
-			if ( !treeView ) {
-				return;
-			}
+	markToSync( type ) {
+		// If the node has no DOM element it is not rendered yet, its children/attributes do not need to be marked to be sync.
+		if ( !this.DOMElement ) {
+			return;
+		}
 
-			treeView.renderer.markToSync( this, type );
+		const treeView = this.getTreeView();
+
+		// If element is not attached to the Tree view it is a child of the detached subtree and will be rendered anyway with this
+		// subtree.
+		if ( !treeView ) {
+			return;
 		}
-	}
 
-	Node.ATTRIBUTES_NEED_UPDATE = Renderer.ATTRIBUTES_NEED_UPDATE;
-	Node.CHILDREN_NEED_UPDATE = Renderer.CHILDREN_NEED_UPDATE;
-	Node.TEXT_NEEDS_UPDATE = Renderer.TEXT_NEEDS_UPDATE;
+		treeView.renderer.markToSync( this, type );
+	}
+}
 
-	return Node;
-} );
+Node.ATTRIBUTES_NEED_UPDATE = Renderer.ATTRIBUTES_NEED_UPDATE;
+Node.CHILDREN_NEED_UPDATE = Renderer.CHILDREN_NEED_UPDATE;
+Node.TEXT_NEEDS_UPDATE = Renderer.TEXT_NEEDS_UPDATE;

+ 94 - 99
packages/ckeditor5-engine/src/treeview/observer/mutationobserver.js

@@ -5,127 +5,122 @@
 
 'use strict';
 
-CKEDITOR.define( [
-	'utils-diff',
-	'treeview/observer/observer',
-	'treeview/element',
-	'treeview/text',
-	'treeview/position'
-], ( diff, Observer, ViewElement, ViewText ) => {
-	class MutationObserver extends Observer {
-		constructor() {
-			super();
-
-			this.config = {
-				childList: true,
-				characterData: true,
-				characterDataOldValue: true,
-				subtree: true
-			};
-		}
+import diff from '../../utils-diff.js';
+import Observer from './observer.js';
+import ViewElement from '../element.js';
+import ViewText from '../text.js';
+
+export default class MutationObserver extends Observer {
+	constructor() {
+		super();
+
+		this.config = {
+			childList: true,
+			characterData: true,
+			characterDataOldValue: true,
+			subtree: true
+		};
+	}
 
-		/**
-		 * @method init
-		 * @param {treeView.TreeView}
-		 */
-		init( treeView ) {
-			this.domRoot = treeView.domRoot;
+	/**
+	 * @method init
+	 * @param {treeView.TreeView}
+	 */
+	init( treeView ) {
+		this.domRoot = treeView.domRoot;
 
-			this._mutationObserver = new window.MutationObserver( this._onMutations.bind( this ) );
-		}
+		this._mutationObserver = new window.MutationObserver( this._onMutations.bind( this ) );
+	}
 
-		/**
-		 * @method attach
-		 */
-		attach() {
-			this._mutationObserver.observe( this.domRoot, this.config );
-		}
+	/**
+	 * @method attach
+	 */
+	attach() {
+		this._mutationObserver.observe( this.domRoot, this.config );
+	}
 
-		/**
-		 * @method detach
-		 */
-		detach() {
-			this._mutationObserver.disconnect();
-		}
+	/**
+	 * @method detach
+	 */
+	detach() {
+		this._mutationObserver.disconnect();
+	}
 
-		_onMutations( domMutations ) {
-			// Use set for deduplication.
-			const mutatedTexts = new Set();
-			const mutatedElements = new Set();
+	_onMutations( domMutations ) {
+		// Use set for deduplication.
+		const mutatedTexts = new Set();
+		const mutatedElements = new Set();
 
-			for ( let mutation of domMutations ) {
-				if ( mutation.type === 'childList' ) {
-					const element = ViewElement.getCorespondingElement( mutation.target );
+		for ( let mutation of domMutations ) {
+			if ( mutation.type === 'childList' ) {
+				const element = ViewElement.getCorespondingElement( mutation.target );
 
-					if ( element ) {
-						mutatedElements.add( element );
-					}
+				if ( element ) {
+					mutatedElements.add( element );
 				}
 			}
+		}
 
-			for ( let mutation of domMutations ) {
-				if ( mutation.type === 'characterData' ) {
-					const text = Text.getCorespondingText( mutation.target );
-
-					if ( text && !mutatedElements.has( text.parent ) ) {
-						mutatedTexts.add( {
-							type: 'text',
-							oldText: text.getText(),
-							newText: mutation.target.data,
-							node: text
-						} );
-					}
+		for ( let mutation of domMutations ) {
+			if ( mutation.type === 'characterData' ) {
+				const text = Text.getCorespondingText( mutation.target );
+
+				if ( text && !mutatedElements.has( text.parent ) ) {
+					mutatedTexts.add( {
+						type: 'text',
+						oldText: text.getText(),
+						newText: mutation.target.data,
+						node: text
+					} );
 				}
 			}
+		}
 
-			const viewMutations = [];
-
-			for ( let mutatedText of mutatedTexts ) {
-				mutatedText.node.markToSync( ViewText.TEXT_NEEDS_UPDATE );
-
-				viewMutations.push( mutatedText );
-			}
+		const viewMutations = [];
 
-			for ( let viewElement of mutatedElements ) {
-				const domElement = viewElement.domElement;
-				const domChildren = domElement.childNodes;
-				const viewChildren = viewElement.getChildren();
-				const newViewChildren = [];
+		for ( let mutatedText of mutatedTexts ) {
+			mutatedText.node.markToSync( ViewText.TEXT_NEEDS_UPDATE );
 
-				for ( let domChild of domChildren ) {
-					newViewChildren.push( ViewElement.createFromDom( domChild ) );
-				}
+			viewMutations.push( mutatedText );
+		}
 
-				viewElement.markToSync( ViewElement.CHILDREN_NEED_UPDATE );
+		for ( let viewElement of mutatedElements ) {
+			const domElement = viewElement.domElement;
+			const domChildren = domElement.childNodes;
+			const viewChildren = viewElement.getChildren();
+			const newViewChildren = [];
 
-				viewMutations.push( {
-					type: 'childNodes',
-					oldChildren: viewElement.getChildren(),
-					newChildren: newViewChildren,
-					diff: diff( viewChildren, newViewChildren, compareNodes ),
-					node: viewElement
-				} );
+			for ( let domChild of domChildren ) {
+				newViewChildren.push( ViewElement.createFromDom( domChild ) );
 			}
 
-			this.fire( 'mutations', viewMutations );
+			viewElement.markToSync( ViewElement.CHILDREN_NEED_UPDATE );
 
-			this.treeView.render();
+			viewMutations.push( {
+				type: 'childNodes',
+				oldChildren: viewElement.getChildren(),
+				newChildren: newViewChildren,
+				diff: diff( viewChildren, newViewChildren, compareNodes ),
+				node: viewElement
+			} );
+		}
 
-			function compareNodes( oldNode, newNode ) {
-				// Elements.
-				if ( oldNode instanceof ViewElement && newNode instanceof ViewElement ) {
-					return oldNode === newNode;
-				}
-				// Texts.
-				else if ( oldNode instanceof ViewText && newNode instanceof ViewText ) {
-					return oldNode.getText() === newNode.getText();
-				}
+		this.fire( 'mutations', viewMutations );
+
+		this.treeView.render();
 
-				// Not matching types.
-				return false;
+		function compareNodes( oldNode, newNode ) {
+			// Elements.
+			if ( oldNode instanceof ViewElement && newNode instanceof ViewElement ) {
+				return oldNode === newNode;
+			}
+			// Texts.
+			else if ( oldNode instanceof ViewText && newNode instanceof ViewText ) {
+				return oldNode.getText() === newNode.getText();
 			}
+
+			// Not matching types.
+			return false;
 		}
 	}
-
-	return MutationObserver;
-} );
+}

+ 12 - 16
packages/ckeditor5-engine/src/treeview/observer/observer.js

@@ -5,21 +5,17 @@
 
 'use strict';
 
-CKEDITOR.define( [], () => {
-	class Observer {
-		/**
-		 * @method init
-		 * @param {treeView.TreeView}
-		 */
+export default class Observer {
+	/**
+	 * @method init
+	 * @param {treeView.TreeView}
+	 */
 
-		/**
-		 * @method attach
-		 */
+	/**
+	 * @method attach
+	 */
 
-		/**
-		 * @method detach
-		 */
-	}
-
-	return Observer;
-} );
+	/**
+	 * @method detach
+	 */
+}

+ 81 - 83
packages/ckeditor5-engine/src/treeview/position.js

@@ -5,106 +5,104 @@
 
 'use strict';
 
-CKEDITOR.define( [ 'ckeditorerror' ], ( CKEditorError ) => {
+import CKEditorError from '../ckeditorerror.js';
+
+/**
+ * Position in the tree. Position is always located before or after a node.
+ *
+ * @class treeModel.Position
+ */
+ export default class Position {
 	/**
-	 * Position in the tree. Position is always located before or after a node.
+	 * Creates a position.
 	 *
-	 * @class treeModel.Position
+	 * @param {treeView.Element} parent Position parent element.
+	 * @param {Number} offset Position offset.
+	 * @constructor
 	 */
-	class Position {
+	constructor( parent, offset ) {
 		/**
-		 * Creates a position.
+		 * Position parent element.
 		 *
-		 * @param {treeView.Element} parent Position parent element.
-		 * @param {Number} offset Position offset.
-		 * @constructor
+		 * @type {treeView.Element}
 		 */
-		constructor( parent, offset ) {
-			/**
-			 * Position parent element.
-			 *
-			 * @type {treeView.Element}
-			 */
-			this.parent = parent;
-
-			/**
-			 * Position offset.
-			 *
-			 * @type {Number}
-			 */
-			this.offset = offset;
-		}
+		this.parent = parent;
 
 		/**
-		 * Node directly after the position.
+		 * Position offset.
 		 *
-		 * @readonly
-		 * @property {treeView.Node}
+		 * @type {Number}
 		 */
-		getNodeAfter() {
-			return this.parent.getChild( this.offset ) || null;
-		}
+		this.offset = offset;
+	}
 
-		/**
-		 * Node directly before the position.
-		 *
-		 * @readonly
-		 * @type {treeView.Node}
-		 */
-		getNodeBefore() {
-			return this.parent.getChild( this.offset - 1 ) || null;
-		}
+	/**
+	 * Node directly after the position.
+	 *
+	 * @readonly
+	 * @property {treeView.Node}
+	 */
+	getNodeAfter() {
+		return this.parent.getChild( this.offset ) || null;
+	}
 
-		/**
-		 * Creates a new position after given node.
-		 *
-		 * @param {treeView.Node} node Node the position should be directly after.
-		 * @returns {treeView.Position}
-		 */
-		static createAfter( node ) {
-			if ( !node.parent ) {
-				/**
-				 * You can not make position after root.
-				 *
-				 * @error position-after-root
-				 * @param {treeView.Node} root
-				 */
-				throw new CKEditorError( 'position-after-root: You can not make position after root.', { root: node } );
-			}
+	/**
+	 * Node directly before the position.
+	 *
+	 * @readonly
+	 * @type {treeView.Node}
+	 */
+	getNodeBefore() {
+		return this.parent.getChild( this.offset - 1 ) || null;
+	}
 
-			return new Position( node.parent, node.getIndex() + 1 );
+	/**
+	 * Creates a new position after given node.
+	 *
+	 * @param {treeView.Node} node Node the position should be directly after.
+	 * @returns {treeView.Position}
+	 */
+	static createAfter( node ) {
+		if ( !node.parent ) {
+			/**
+			 * You can not make position after root.
+			 *
+			 * @error position-after-root
+			 * @param {treeView.Node} root
+			 */
+			throw new CKEditorError( 'position-after-root: You can not make position after root.', { root: node } );
 		}
 
-		/**
-		 * Creates a new position before the given node.
-		 *
-		 * @param {treeView.node} node Node the position should be directly before.
-		 * @returns {treeView.Position}
-		 */
-		static createBefore( node ) {
-			if ( !node.parent ) {
-				/**
-				 * You can not make position before root.
-				 *
-				 * @error position-before-root
-				 * @param {treeView.Node} root
-				 */
-				throw new CKEditorError( 'position-before-root: You can not make position before root.', { root: node } );
-			}
+		return new Position( node.parent, node.getIndex() + 1 );
+	}
 
-			return new Position( node.parent, node.getIndex() );
+	/**
+	 * Creates a new position before the given node.
+	 *
+	 * @param {treeView.node} node Node the position should be directly before.
+	 * @returns {treeView.Position}
+	 */
+	static createBefore( node ) {
+		if ( !node.parent ) {
+			/**
+			 * You can not make position before root.
+			 *
+			 * @error position-before-root
+			 * @param {treeView.Node} root
+			 */
+			throw new CKEditorError( 'position-before-root: You can not make position before root.', { root: node } );
 		}
 
-		/**
-		 * Creates and returns a new instance of Position, which is equal to passed position.
-		 *
-		 * @param {treeView.Position} position Position to be cloned.
-		 * @returns {treeView.Position}
-		 */
-		static createFromPosition( position ) {
-			return new this( position.parent, position.offset );
-		}
+		return new Position( node.parent, node.getIndex() );
 	}
 
-	return Position;
-} );
+	/**
+	 * Creates and returns a new instance of Position, which is equal to passed position.
+	 *
+	 * @param {treeView.Position} position Position to be cloned.
+	 * @returns {treeView.Position}
+	 */
+	static createFromPosition( position ) {
+		return new this( position.parent, position.offset );
+	}
+}

+ 102 - 106
packages/ckeditor5-engine/src/treeview/renderer.js

@@ -5,142 +5,138 @@
 
 'use strict';
 
-CKEDITOR.define( [
-	'utils-diff',
-	'treeview/element',
-	'treeview/text'
-], ( diff, ViewElement, ViewText ) => {
-	const ATTRIBUTES_NEED_UPDATE = 0;
-	const CHILDREN_NEED_UPDATE = 1;
-	const TEXT_NEEDS_UPDATE = 2;
-
-	class Renderer {
-		constructor( treeView ) {
-			this.view = treeView.view;
-
-			this.domRoot = treeView.domRoot;
-
-			this.markedAttrs = new Set();
-			this.markedChildren = new Set();
-			this.markedTexts = new Set();
-		}
+import diff from '../utils-diff.js';
+import ViewText from './text.js';
+import ViewElement from './element.js';
 
-		markToSync( node, type ) {
-			if ( type === ATTRIBUTES_NEED_UPDATE ) {
-				this.markedAttrs.push( node );
-			} else if ( type === CHILDREN_NEED_UPDATE ) {
-				this.markedChildren.push( node );
-			} else if ( type === TEXT_NEEDS_UPDATE ) {
-				this.markedTexts.push( node );
-			}
+const ATTRIBUTES_NEED_UPDATE = 0;
+const CHILDREN_NEED_UPDATE = 1;
+const TEXT_NEEDS_UPDATE = 2;
+
+export default class Renderer {
+	constructor( treeView ) {
+		this.view = treeView.view;
+
+		this.domRoot = treeView.domRoot;
+
+		this.markedAttrs = new Set();
+		this.markedChildren = new Set();
+		this.markedTexts = new Set();
+	}
+
+	markToSync( node, type ) {
+		if ( type === ATTRIBUTES_NEED_UPDATE ) {
+			this.markedAttrs.push( node );
+		} else if ( type === CHILDREN_NEED_UPDATE ) {
+			this.markedChildren.push( node );
+		} else if ( type === TEXT_NEEDS_UPDATE ) {
+			this.markedTexts.push( node );
 		}
+	}
 
-		render() {
-			const domDocument = this.domRoot.ownerDocument;
+	render() {
+		const domDocument = this.domRoot.ownerDocument;
 
-			for ( let node of this.markedTexts ) {
-				if ( !this.markedChildren.has( node.parent ) && node.parent.domElement ) {
-					updateText( node );
-				}
+		for ( let node of this.markedTexts ) {
+			if ( !this.markedChildren.has( node.parent ) && node.parent.domElement ) {
+				updateText( node );
 			}
+		}
 
-			for ( let element of this.markedAttrs ) {
-				updateAttrs( element );
-			}
+		for ( let element of this.markedAttrs ) {
+			updateAttrs( element );
+		}
 
-			for ( let element of this.markedChildren ) {
-				updateChildren( element );
-			}
+		for ( let element of this.markedChildren ) {
+			updateChildren( element );
+		}
 
-			function updateText( viewText ) {
-				const domText = viewText.getDomNode();
+		function updateText( viewText ) {
+			const domText = viewText.getDomNode();
 
-				if ( domText.data != viewText.getText() ) {
-					domText.data = viewText.getText();
-				}
+			if ( domText.data != viewText.getText() ) {
+				domText.data = viewText.getText();
 			}
+		}
 
-			function updateAttrs( viewElement ) {
-				const domElement = viewElement.domElement;
-				const domAttrKeys = domElement.attributes;
-				const viewAttrKeys = viewElement.getAttrKeys();
+		function updateAttrs( viewElement ) {
+			const domElement = viewElement.domElement;
+			const domAttrKeys = domElement.attributes;
+			const viewAttrKeys = viewElement.getAttrKeys();
 
-				// Add or overwrite attributes.
-				for ( let key of viewAttrKeys ) {
-					domElement.setAttribute( key, viewElement.getAttr( key ) );
-				}
+			// Add or overwrite attributes.
+			for ( let key of viewAttrKeys ) {
+				domElement.setAttribute( key, viewElement.getAttr( key ) );
+			}
 
-				// Remove from DOM attributes which do not exists in the view.
-				for ( let key of domAttrKeys ) {
-					if ( !viewElement.hasAttr( key ) ) {
-						domElement.removeAttribute( key );
-					}
+			// Remove from DOM attributes which do not exists in the view.
+			for ( let key of domAttrKeys ) {
+				if ( !viewElement.hasAttr( key ) ) {
+					domElement.removeAttribute( key );
 				}
 			}
+		}
 
-			function updateChildren( viewElement ) {
-				const domElement = viewElement.domElement;
-				const domChildren = domElement.childNodes;
-				const viewChildren = viewElement.getChildren();
+		function updateChildren( viewElement ) {
+			const domElement = viewElement.domElement;
+			const domChildren = domElement.childNodes;
+			const viewChildren = viewElement.getChildren();
 
-				const actions = diff( domChildren, viewChildren, compareNodes );
+			const actions = diff( domChildren, viewChildren, compareNodes );
 
-				let i = 0;
+			let i = 0;
 
-				for ( let action of actions ) {
-					if ( action === diff.EQUAL ) {
-						i++;
-					} else if ( action === diff.INSERT ) {
-						domElement.insertBefore( viewToDom( viewChildren[ i ] ), domChildren[ i ] || null  );
-						i++;
-					} else if ( action === diff.DELETE ) {
-						domElement.removeChild( domChildren[ i ] );
-					}
+			for ( let action of actions ) {
+				if ( action === diff.EQUAL ) {
+					i++;
+				} else if ( action === diff.INSERT ) {
+					domElement.insertBefore( viewToDom( viewChildren[ i ] ), domChildren[ i ] || null  );
+					i++;
+				} else if ( action === diff.DELETE ) {
+					domElement.removeChild( domChildren[ i ] );
 				}
 			}
+		}
 
-			function compareNodes( domNode, viewNode ) {
-				// Elements.
-				if ( domNode instanceof HTMLElement && viewNode instanceof ViewElement ) {
-					return domNode === viewNode.DOMElement;
-				}
-				// Texts.
-				else if ( domNode instanceof Text && viewNode instanceof ViewText ) {
-					return domNode.data === viewNode.getText();
-				}
-
-				// Not matching types.
-				return false;
+		function compareNodes( domNode, viewNode ) {
+			// Elements.
+			if ( domNode instanceof HTMLElement && viewNode instanceof ViewElement ) {
+				return domNode === viewNode.DOMElement;
+			}
+			// Texts.
+			else if ( domNode instanceof Text && viewNode instanceof ViewText ) {
+				return domNode.data === viewNode.getText();
 			}
 
-			function viewToDom( view ) {
-				if ( view.domElement ) {
-					return view.domElement;
-				}
+			// Not matching types.
+			return false;
+		}
 
-				if ( view instanceof ViewText ) {
-					return domDocument.createTextNode( view.getText() );
-				} else {
-					const domElement = domDocument.createElement( view.name );
-					view.setDomElement( domElement );
+		function viewToDom( view ) {
+			if ( view.domElement ) {
+				return view.domElement;
+			}
 
-					for ( let key of view.getAttrKeys() ) {
-						domElement.setAttribute( key, view.getAttr( key ) );
-					}
+			if ( view instanceof ViewText ) {
+				return domDocument.createTextNode( view.getText() );
+			} else {
+				const domElement = domDocument.createElement( view.name );
+				view.setDomElement( domElement );
 
-					for ( let childView of view.getChildren() ) {
-						domElement.appendChild( viewToDom( childView ) );
-					}
+				for ( let key of view.getAttrKeys() ) {
+					domElement.setAttribute( key, view.getAttr( key ) );
+				}
 
-					return domElement;
+				for ( let childView of view.getChildren() ) {
+					domElement.appendChild( viewToDom( childView ) );
 				}
+
+				return domElement;
 			}
 		}
 	}
+}
 
-	Renderer.ATTRIBUTES_NEED_UPDATE = ATTRIBUTES_NEED_UPDATE;
-	Renderer.CHILDREN_NEED_UPDATE = CHILDREN_NEED_UPDATE;
-	Renderer.TEXT_NEEDS_UPDATE = TEXT_NEEDS_UPDATE;
-
-	return Renderer;
-} );
+Renderer.ATTRIBUTES_NEED_UPDATE = ATTRIBUTES_NEED_UPDATE;
+Renderer.CHILDREN_NEED_UPDATE = CHILDREN_NEED_UPDATE;
+Renderer.TEXT_NEEDS_UPDATE = TEXT_NEEDS_UPDATE;

+ 14 - 16
packages/ckeditor5-engine/src/treeview/rootelement.js

@@ -5,23 +5,21 @@
 
 'use strict';
 
-CKEDITOR.define( [ 'treeview/element' ], ( Element ) => {
-	/**
-	 * Class for nodes that are roots of trees in tree data view.
-	 *
-	 * @class treeView.RootElement
-	 */
-	class RootElement extends Element {
-		constructor( TreeView, name ) {
-			super( name );
+import Element from './element.js';
 
-			this._treeView = TreeView;
-		}
+/**
+ * Class for nodes that are roots of trees in tree data view.
+ *
+ * @class treeView.RootElement
+ */
+export default class RootElement extends Element {
+	constructor( TreeView, name ) {
+		super( name );
 
-		getTreeView() {
-			return this._treeView;
-		}
+		this._treeView = TreeView;
 	}
 
-	return RootElement;
-} );
+	getTreeView() {
+		return this._treeView;
+	}
+}

+ 38 - 39
packages/ckeditor5-engine/src/treeview/text.js

@@ -5,60 +5,59 @@
 
 'use strict';
 
-CKEDITOR.define( [ 'treeview/Node', 'treeview/Element' ], ( Node, Element ) => {
-	class Text extends Node {
-		constructor( text ) {
-			this._text = text;
-		}
+import Node from './node.js';
+import Element from './element.js';
 
-		getText() {
-			return this._text;
-		}
+export default class Text extends Node {
+	constructor( text ) {
+		this._text = text;
+	}
 
-		setText( text ) {
-			this.markToSync( Node.TEXT_NEEDS_UPDATE );
+	getText() {
+		return this._text;
+	}
 
-			this._text = text;
-		}
+	setText( text ) {
+		this.markToSync( Node.TEXT_NEEDS_UPDATE );
 
-		getDomText() {
-			const previousSibling = this.getPreviousSibling();
+		this._text = text;
+	}
 
-			if ( previousSibling && previousSibling.domElement ) {
-				return previousSibling.domElement.nextSibling;
-			}
+	getDomText() {
+		const previousSibling = this.getPreviousSibling();
 
-			if ( !previousSibling && this.parent.domElement ) {
-				return this.parent.domElement.childNodes[ 0 ];
-			}
+		if ( previousSibling && previousSibling.domElement ) {
+			return previousSibling.domElement.nextSibling;
+		}
 
-			return null;
+		if ( !previousSibling && this.parent.domElement ) {
+			return this.parent.domElement.childNodes[ 0 ];
 		}
 
-		static getCorespondingText( domText ) {
-			const previousSibling = domText.previousSibling;
+		return null;
+	}
 
-			if ( previousSibling ) {
-				const viewElement = Element.getCorespondingElement( previousSibling );
+	static getCorespondingText( domText ) {
+		const previousSibling = domText.previousSibling;
 
-				if ( viewElement ) {
-					return viewElement.getNextSibling;
-				}
-			} else {
-				const viewElement = Element.getCorespondingElement( this.parent );
+		if ( previousSibling ) {
+			const viewElement = Element.getCorespondingElement( previousSibling );
 
-				if ( viewElement ) {
-					return viewElement.getChild[ 0 ];
-				}
+			if ( viewElement ) {
+				return viewElement.getNextSibling;
 			}
+		} else {
+			const viewElement = Element.getCorespondingElement( this.parent );
 
-			if ( !previousSibling && this.parent.domElement ) {
-				return this.parent.domElement.childNodes[ 0 ];
+			if ( viewElement ) {
+				return viewElement.getChild[ 0 ];
 			}
+		}
 
-			return null;
+		if ( !previousSibling && this.parent.domElement ) {
+			return this.parent.domElement.childNodes[ 0 ];
 		}
-	}
 
-	return Text;
-} );
+		return null;
+	}
+}

+ 36 - 40
packages/ckeditor5-engine/src/treeview/treeview.js

@@ -5,50 +5,46 @@
 
 'use strict';
 
-CKEDITOR.define( [
-	'utils',
-	'emittermixin',
-	'treeview/rootelement',
-	'treeview/renderer'
-], ( utils, EmitterMixin, RootElement, Renderer ) => {
-	class TreeView {
-		constructor( domElement ) {
-			/**
-			 * Root of the view
-			 */
-			this.viewRoot = new RootElement( this, domElement.name );
-			this.viewRoot.cloneDOMAttrs();
-
-			/**
-			 * Root of the DOM.
-			 */
-			this.domRoot = domElement;
-
-			this.observers = new Set();
-
-			this.renderer = new Renderer( this );
-		}
+import utils from '../utils.js';
+import EmitterMixin from './emittermixin.js';
+import RootElement from './rootelement.js';
+import Renderer from './renderer.js';
+
+export default class TreeView {
+	constructor( domElement ) {
+		/**
+		 * Root of the view
+		 */
+		this.viewRoot = new RootElement( this, domElement.name );
+		this.viewRoot.cloneDOMAttrs();
+
+		/**
+		 * Root of the DOM.
+		 */
+		this.domRoot = domElement;
+
+		this.observers = new Set();
+
+		this.renderer = new Renderer( this );
+	}
 
-		addObserver( observer ) {
-			this.observers.push( observer );
-			observer.init( this );
-			observer.attach();
-		}
+	addObserver( observer ) {
+		this.observers.push( observer );
+		observer.init( this );
+		observer.attach();
+	}
 
-		render() {
-			for ( let observer of this.observers ) {
-				observer.detach();
-			}
+	render() {
+		for ( let observer of this.observers ) {
+			observer.detach();
+		}
 
-			this.renderer.render();
+		this.renderer.render();
 
-			for ( let observer of this.observers ) {
-				observer.attach();
-			}
+		for ( let observer of this.observers ) {
+			observer.attach();
 		}
 	}
+}
 
-	utils.extend( Document.prototype, EmitterMixin );
-
-	return TreeView;
-} );
+utils.extend( Document.prototype, EmitterMixin );