ng2-tree
Version:
angular2 component for visualizing data that can be naturally represented as a tree
562 lines • 69.9 kB
JavaScript
import { defaultsDeep, get, has, includes, isEmpty, isFunction, isNil, omit, once, size, trim } from './utils/fn.utils';
import { FoldingType, TreeModelSettings, TreeStatus } from './tree.types';
import * as uuidv4 from 'uuid/v4';
import { Observable, of } from 'rxjs';
var ChildrenLoadingState;
(function (ChildrenLoadingState) {
ChildrenLoadingState[ChildrenLoadingState["NotStarted"] = 0] = "NotStarted";
ChildrenLoadingState[ChildrenLoadingState["Loading"] = 1] = "Loading";
ChildrenLoadingState[ChildrenLoadingState["Completed"] = 2] = "Completed";
})(ChildrenLoadingState || (ChildrenLoadingState = {}));
export class Tree {
_children;
_loadChildren;
_childrenLoadingState = ChildrenLoadingState.NotStarted;
_childrenAsyncOnce = once(() => {
return new Observable((observer) => {
setTimeout(() => {
this._childrenLoadingState = ChildrenLoadingState.Loading;
this._loadChildren((children) => {
this._children = (children || []).map((child) => new Tree(child, this));
this._childrenLoadingState = ChildrenLoadingState.Completed;
observer.next(this.children);
observer.complete();
});
});
});
});
node;
parent;
// STATIC METHODS ----------------------------------------------------------------------------------------------------
/**
* Check that value passed is not empty (it doesn't consist of only whitespace symbols).
* @param {string} value - A value that should be checked.
* @returns {boolean} - A flag indicating that value is empty or not.
* @static
*/
static isValueEmpty(value) {
return isEmpty(trim(value));
}
/**
* Check whether a given value can be considered RenamableNode.
* @param {any} value - A value to check.
* @returns {boolean} - A flag indicating whether given value is Renamable node or not.
* @static
*/
static isRenamable(value) {
return (has(value, 'setName') &&
isFunction(value.setName) &&
(has(value, 'toString') && isFunction(value.toString) && value.toString !== Object.toString));
}
static cloneTreeShallow(origin) {
const tree = new Tree(Object.assign({}, origin.node));
tree._children = origin._children;
return tree;
}
static applyNewValueToRenamable(value, newValue) {
const renamableValue = Object.assign({}, value);
renamableValue.setName(newValue);
return renamableValue;
}
/**
* Build an instance of Tree from an object implementing TreeModel interface.
* @param {TreeModel} model - A model that is used to build a tree.
* @param {Tree} [parent] - An optional parent if you want to build a tree from the model that should be a child of an existing Tree instance.
* @param {boolean} [isBranch] - An option that makes a branch from created tree. Branch can have children.
*/
constructor(node, parent = null, isBranch = false) {
this.buildTreeFromModel(node, parent, isBranch || Array.isArray(node.children));
}
buildTreeFromModel(model, parent, isBranch) {
this.parent = parent;
this.node = Object.assign(omit(model, 'children'), { settings: TreeModelSettings.merge(model, get(parent, 'node')) }, { emitLoadNextLevel: model.emitLoadNextLevel === true });
if (isFunction(this.node.loadChildren)) {
this._loadChildren = this.node.loadChildren;
}
else {
get(model, 'children', []).forEach((child, index) => {
this._addChild(new Tree(child, this), index);
});
}
if (!Array.isArray(this._children)) {
this._children = this.node.loadChildren || isBranch ? [] : null;
}
}
hasDeferredChildren() {
return typeof this._loadChildren === 'function';
}
/* Setting the children loading state to Loading since a request was dispatched to the client */
loadingChildrenRequested() {
this._childrenLoadingState = ChildrenLoadingState.Loading;
}
/**
* Check whether children of the node are being loaded.
* Makes sense only for nodes that define `loadChildren` function.
* @returns {boolean} A flag indicating that children are being loaded.
*/
childrenAreBeingLoaded() {
return this._childrenLoadingState === ChildrenLoadingState.Loading;
}
/**
* Check whether children of the node were loaded.
* Makes sense only for nodes that define `loadChildren` function.
* @returns {boolean} A flag indicating that children were loaded.
*/
childrenWereLoaded() {
return this._childrenLoadingState === ChildrenLoadingState.Completed;
}
canLoadChildren() {
return (this._childrenLoadingState === ChildrenLoadingState.NotStarted &&
this.foldingType === FoldingType.Expanded &&
!!this._loadChildren);
}
/**
* Check whether children of the node should be loaded and not loaded yet.
* Makes sense only for nodes that define `loadChildren` function.
* @returns {boolean} A flag indicating that children should be loaded for the current node.
*/
childrenShouldBeLoaded() {
return !this.childrenWereLoaded() && (!!this._loadChildren || this.node.emitLoadNextLevel === true);
}
/**
* Get children of the current tree.
* @returns {Tree[]} The children of the current tree.
*/
get children() {
return this._children;
}
/**
* By getting value from this property you start process of loading node's children using `loadChildren` function.
* Once children are loaded `loadChildren` function won't be called anymore and loaded for the first time children are emitted in case of subsequent calls.
* @returns {Observable<Tree[]>} An observable which emits children once they are loaded.
*/
get childrenAsync() {
if (this.canLoadChildren()) {
return this._childrenAsyncOnce();
}
return of(this.children);
}
/**
* By calling this method you start process of loading node's children using `loadChildren` function.
*/
reloadChildren() {
if (this.childrenShouldBeLoaded()) {
this._childrenLoadingState = ChildrenLoadingState.Loading;
this._loadChildren((children) => {
this._children = children && children.map((child) => new Tree(child, this));
this._childrenLoadingState = ChildrenLoadingState.Completed;
});
}
}
/**
* By calling this method you will remove all current children of a treee and create new.
*/
setChildren(children) {
this._children = children && children.map((child) => new Tree(child, this));
if (this.childrenShouldBeLoaded()) {
this._childrenLoadingState = ChildrenLoadingState.Completed;
}
}
/**
* Create a new node in the current tree.
* @param {boolean} isBranch - A flag that indicates whether a new node should be a "Branch". "Leaf" node will be created by default
* @param {TreeModel} model - Tree model of the new node which will be inserted. Empty node will be created by default and it will fire edit mode of this node
* @returns {Tree} A newly created child node.
*/
createNode(isBranch, model = { value: '' }) {
const tree = new Tree(model, this, isBranch);
if (!model.id) {
tree.markAsNew();
}
tree.id = tree.id || uuidv4();
if (this.childrenShouldBeLoaded() && !(this.childrenAreBeingLoaded() || this.childrenWereLoaded())) {
return null;
}
if (this.isLeaf()) {
return this.addSibling(tree);
}
else {
return this.addChild(tree);
}
}
/**
* Get the value of the current node
* @returns {(string|RenamableNode)} The value of the node.
*/
get value() {
return this.node.value;
}
set checked(checked) {
this.node.settings = Object.assign({}, this.node.settings, { checked });
}
get checked() {
return !!get(this.node.settings, 'checked');
}
get checkedChildren() {
return this.hasLoadedChildern() ? this.children.filter(child => child.checked) : [];
}
set selectionAllowed(selectionAllowed) {
this.node.settings = Object.assign({}, this.node.settings, { selectionAllowed });
}
get selectionAllowed() {
const value = get(this.node.settings, 'selectionAllowed');
return isNil(value) ? true : !!value;
}
hasLoadedChildern() {
return !isEmpty(this.children);
}
loadedChildrenAmount() {
return size(this.children);
}
checkedChildrenAmount() {
return size(this.checkedChildren);
}
/**
* Set the value of the current node
* @param {(string|RenamableNode)} value - The new value of the node.
*/
set value(value) {
if (typeof value !== 'string' && !Tree.isRenamable(value)) {
return;
}
const stringifiedValue = '' + value;
if (Tree.isRenamable(this.value)) {
this.node.value = Tree.applyNewValueToRenamable(this.value, stringifiedValue);
}
else {
this.node.value = Tree.isValueEmpty(stringifiedValue) ? this.node.value : stringifiedValue;
}
}
/**
* Add a sibling node for the current node. This won't work if the current node is a root.
* @param {Tree} sibling - A node that should become a sibling.
* @param [number] position - Position in which sibling will be inserted. By default it will be inserted at the last position in a parent.
* @returns {Tree} A newly inserted sibling, or null if you are trying to make a sibling for the root.
*/
addSibling(sibling, position) {
if (Array.isArray(get(this.parent, 'children'))) {
return this.parent.addChild(sibling, position);
}
return null;
}
/**
* Add a child node for the current node.
* @param {Tree} child - A node that should become a child.
* @param [number] position - Position in which child will be inserted. By default it will be inserted at the last position in a parent.
* @returns {Tree} A newly inserted child.
*/
addChild(child, position) {
const newborn = this._addChild(Tree.cloneTreeShallow(child), position);
this._setFoldingType();
if (this.isNodeCollapsed()) {
this.switchFoldingType();
}
return newborn;
}
_addChild(child, position = size(this._children) || 0) {
child.parent = this;
if (Array.isArray(this._children)) {
this._children.splice(position, 0, child);
}
else {
this._children = [child];
}
return child;
}
/**
* Swap position of the current node with the given sibling. If node passed as a parameter is not a sibling - nothing happens.
* @param {Tree} sibling - A sibling with which current node shold be swapped.
*/
swapWithSibling(sibling) {
if (!this.hasSibling(sibling)) {
return;
}
const siblingIndex = sibling.positionInParent;
const thisTreeIndex = this.positionInParent;
this.parent._children[siblingIndex] = this;
this.parent._children[thisTreeIndex] = sibling;
}
/**
* Get a node's position in its parent.
* @returns {number} The position inside a parent.
*/
get positionInParent() {
if (this.isRoot()) {
return -1;
}
return this.parent.children ? this.parent.children.indexOf(this) : -1;
}
/**
* Check whether or not this tree is static.
* @returns {boolean} A flag indicating whether or not this tree is static.
*/
isStatic() {
return get(this.node.settings, 'static', false);
}
/**
* Check whether or not this tree has a left menu.
* @returns {boolean} A flag indicating whether or not this tree has a left menu.
*/
hasLeftMenu() {
return !get(this.node.settings, 'static', false) && get(this.node.settings, 'leftMenu', false);
}
/**
* Check whether or not this tree has a right menu.
* @returns {boolean} A flag indicating whether or not this tree has a right menu.
*/
hasRightMenu() {
return !get(this.node.settings, 'static', false) && get(this.node.settings, 'rightMenu', false);
}
/**
* Check whether this tree is "Leaf" or not.
* @returns {boolean} A flag indicating whether or not this tree is a "Leaf".
*/
isLeaf() {
return !this.isBranch();
}
/**
* Get menu items of the current tree.
* @returns {NodeMenuItem[]} The menu items of the current tree.
*/
get menuItems() {
return get(this.node.settings, 'menuItems');
}
/**
* Check whether or not this tree has a custom menu.
* @returns {boolean} A flag indicating whether or not this tree has a custom menu.
*/
hasCustomMenu() {
return !this.isStatic() && !!get(this.node.settings, 'menuItems', false);
}
/**
* Check whether this tree is "Branch" or not. "Branch" is a node that has children.
* @returns {boolean} A flag indicating whether or not this tree is a "Branch".
*/
isBranch() {
return this.node.emitLoadNextLevel === true || Array.isArray(this._children);
}
/**
* Check whether this tree has children.
* @returns {boolean} A flag indicating whether or not this tree has children.
*/
hasChildren() {
return !isEmpty(this._children) || this.childrenShouldBeLoaded();
}
/**
* Check whether this tree is a root or not. The root is the tree (node) that doesn't have parent (or technically its parent is null).
* @returns {boolean} A flag indicating whether or not this tree is the root.
*/
isRoot() {
return isNil(this.parent);
}
/**
* Check whether provided tree is a sibling of the current tree. Sibling trees (nodes) are the trees that have the same parent.
* @param {Tree} tree - A tree that should be tested on a siblingness.
* @returns {boolean} A flag indicating whether or not provided tree is the sibling of the current one.
*/
hasSibling(tree) {
return !this.isRoot() && includes(this.parent.children, tree);
}
/**
* Check whether provided tree is a child of the current tree.
* This method tests that provided tree is a <strong>direct</strong> child of the current tree.
* @param {Tree} tree - A tree that should be tested (child candidate).
* @returns {boolean} A flag indicating whether provided tree is a child or not.
*/
hasChild(tree) {
return includes(this._children, tree);
}
/**
* Remove given tree from the current tree.
* The given tree will be removed only in case it is a direct child of the current tree (@see {@link hasChild}).
* @param {Tree} tree - A tree that should be removed.
*/
removeChild(tree) {
if (!this.hasChildren()) {
return;
}
const childIndex = this._children.findIndex((child) => child === tree);
if (childIndex >= 0) {
this._children.splice(childIndex, 1);
}
this._setFoldingType();
}
/**
* Remove current tree from its parent.
*/
removeItselfFromParent() {
if (!this.parent) {
return;
}
this.parent.removeChild(this);
}
/**
* Switch folding type of the current tree. "Leaf" node cannot switch its folding type cause it doesn't have children, hence nothing to fold.
* If node is a "Branch" and it is expanded, then by invoking current method state of the tree should be switched to "collapsed" and vice versa.
*/
switchFoldingType() {
if (this.isLeaf() || !this.hasChildren()) {
return;
}
this.disableCollapseOnInit();
this.node._foldingType = this.isNodeExpanded() ? FoldingType.Collapsed : FoldingType.Expanded;
}
/**
* Check that tree is expanded.
* @returns {boolean} A flag indicating whether current tree is expanded. Always returns false for the "Leaf" tree and for an empty tree.
*/
isNodeExpanded() {
return this.foldingType === FoldingType.Expanded;
}
/**
* Check that tree is collapsed.
* @returns {boolean} A flag indicating whether current tree is collapsed. Always returns false for the "Leaf" tree and for an empty tree.
*/
isNodeCollapsed() {
return this.foldingType === FoldingType.Collapsed;
}
/**
* Set a current folding type: expanded, collapsed or leaf.
*/
_setFoldingType() {
if (this.childrenShouldBeLoaded()) {
this.node._foldingType = FoldingType.Collapsed;
}
else if (this._children && !isEmpty(this._children)) {
this.node._foldingType = this.isCollapsedOnInit() ? FoldingType.Collapsed : FoldingType.Expanded;
}
else if (Array.isArray(this._children)) {
this.node._foldingType = FoldingType.Empty;
}
else {
this.node._foldingType = FoldingType.Leaf;
}
}
/**
* Get a current folding type: expanded, collapsed or leaf.
* @returns {FoldingType} A folding type of the current tree.
*/
get foldingType() {
if (!this.node._foldingType) {
this._setFoldingType();
}
return this.node._foldingType;
}
/**
* Get a css class for element which displayes folding state - expanded, collapsed or leaf
* @returns {string} A string icontaining css class (classes)
*/
get foldingCssClass() {
return this.getCssClassesFromSettings() || this.foldingType.cssClass;
}
getCssClassesFromSettings() {
if (!this.node._foldingType) {
this._setFoldingType();
}
if (this.node._foldingType === FoldingType.Collapsed) {
return get(this.node.settings, 'cssClasses.collapsed', null);
}
else if (this.node._foldingType === FoldingType.Expanded) {
return get(this.node.settings, 'cssClasses.expanded', null);
}
else if (this.node._foldingType === FoldingType.Empty) {
return get(this.node.settings, 'cssClasses.empty', null);
}
return get(this.node.settings, 'cssClasses.leaf', null);
}
/**
* Get a html template to render before every node's name.
* @returns {string} A string representing a html template.
*/
get nodeTemplate() {
return this.getTemplateFromSettings();
}
getTemplateFromSettings() {
if (this.isLeaf()) {
return get(this.node.settings, 'templates.leaf', '');
}
else {
return get(this.node.settings, 'templates.node', '');
}
}
/**
* Get a html template to render for an element activatin left menu of a node.
* @returns {string} A string representing a html template.
*/
get leftMenuTemplate() {
if (this.hasLeftMenu()) {
return get(this.node.settings, 'templates.leftMenu', '<span></span>');
}
return '';
}
disableCollapseOnInit() {
if (this.node.settings) {
this.node.settings.isCollapsedOnInit = false;
}
}
isCollapsedOnInit() {
return !!get(this.node.settings, 'isCollapsedOnInit');
}
keepNodesInDOM() {
return get(this.node.settings, 'keepNodesInDOM');
}
/**
* Check that current tree is newly created (added by user via menu for example). Tree that was built from the TreeModel is not marked as new.
* @returns {boolean} A flag whether the tree is new.
*/
isNew() {
return this.node._status === TreeStatus.New;
}
get id() {
return get(this.node, 'id');
}
set id(id) {
this.node.id = id;
}
/**
* Mark current tree as new (@see {@link isNew}).
*/
markAsNew() {
this.node._status = TreeStatus.New;
}
/**
* Check that current tree is being renamed (it is in the process of its value renaming initiated by a user).
* @returns {boolean} A flag whether the tree is being renamed.
*/
isBeingRenamed() {
return this.node._status === TreeStatus.IsBeingRenamed;
}
/**
* Mark current tree as being renamed (@see {@link isBeingRenamed}).
*/
markAsBeingRenamed() {
this.node._status = TreeStatus.IsBeingRenamed;
}
/**
* Check that current tree is modified (for example it was renamed).
* @returns {boolean} A flag whether the tree is modified.
*/
isModified() {
return this.node._status === TreeStatus.Modified;
}
/**
* Mark current tree as modified (@see {@link isModified}).
*/
markAsModified() {
this.node._status = TreeStatus.Modified;
}
/**
* Makes a clone of an underlying TreeModel instance
* @returns {TreeModel} a clone of an underlying TreeModel instance
*/
toTreeModel() {
const model = defaultsDeep(this.isLeaf() ? {} : { children: [] }, this.node);
if (this.children) {
this.children.forEach(child => {
model.children.push(child.toTreeModel());
});
}
return model;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../src/tree.ts"],"names":[],"mappings":"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","sourcesContent":["import { defaultsDeep, get, has, includes, isEmpty, isFunction, isNil, omit, once, size, trim } from './utils/fn.utils';\n\nimport {\n  ChildrenLoadingFunction,\n  FoldingType,\n  RenamableNode,\n  TreeModel,\n  TreeModelSettings,\n  TreeStatus\n} from './tree.types';\nimport { NodeMenuItem } from './menu/node-menu.component';\n\nimport * as uuidv4 from 'uuid/v4';\nimport { Observable, Observer, of } from 'rxjs';\n\nenum ChildrenLoadingState {\n  NotStarted,\n  Loading,\n  Completed\n}\n\nexport class Tree {\n  private _children: Tree[];\n  private _loadChildren: ChildrenLoadingFunction;\n  private _childrenLoadingState: ChildrenLoadingState = ChildrenLoadingState.NotStarted;\n  private _childrenAsyncOnce: () => Observable<Tree[]> = once(() => {\n    return new Observable((observer: Observer<Tree[]>) => {\n      setTimeout(() => {\n        this._childrenLoadingState = ChildrenLoadingState.Loading;\n        this._loadChildren((children: TreeModel[]) => {\n          this._children = (children || []).map((child: TreeModel) => new Tree(child, this));\n          this._childrenLoadingState = ChildrenLoadingState.Completed;\n          observer.next(this.children);\n          observer.complete();\n        });\n      });\n    });\n  });\n\n  public node: TreeModel;\n  public parent: Tree;\n\n  // STATIC METHODS ----------------------------------------------------------------------------------------------------\n\n  /**\n   * Check that value passed is not empty (it doesn't consist of only whitespace symbols).\n   * @param {string} value - A value that should be checked.\n   * @returns {boolean} - A flag indicating that value is empty or not.\n   * @static\n   */\n  public static isValueEmpty(value: string): boolean {\n    return isEmpty(trim(value));\n  }\n\n  /**\n   * Check whether a given value can be considered RenamableNode.\n   * @param {any} value - A value to check.\n   * @returns {boolean} - A flag indicating whether given value is Renamable node or not.\n   * @static\n   */\n  public static isRenamable(value: any): value is RenamableNode {\n    return (\n      has(value, 'setName') &&\n      isFunction(value.setName) &&\n      (has(value, 'toString') && isFunction(value.toString) && value.toString !== Object.toString)\n    );\n  }\n\n  private static cloneTreeShallow(origin: Tree): Tree {\n    const tree = new Tree(Object.assign({}, origin.node));\n    tree._children = origin._children;\n    return tree;\n  }\n\n  private static applyNewValueToRenamable(value: RenamableNode, newValue: string): RenamableNode {\n    const renamableValue: RenamableNode = Object.assign({}, value as RenamableNode);\n    renamableValue.setName(newValue);\n    return renamableValue;\n  }\n\n  /**\n   * Build an instance of Tree from an object implementing TreeModel interface.\n   * @param {TreeModel} model - A model that is used to build a tree.\n   * @param {Tree} [parent] - An optional parent if you want to build a tree from the model that should be a child of an existing Tree instance.\n   * @param {boolean} [isBranch] - An option that makes a branch from created tree. Branch can have children.\n   */\n  public constructor(node: TreeModel, parent: Tree = null, isBranch: boolean = false) {\n    this.buildTreeFromModel(node, parent, isBranch || Array.isArray(node.children));\n  }\n\n  private buildTreeFromModel(model: TreeModel, parent: Tree, isBranch: boolean): void {\n    this.parent = parent;\n    this.node = Object.assign(\n      omit(model, 'children') as TreeModel,\n      { settings: TreeModelSettings.merge(model, get(parent, 'node')) },\n      { emitLoadNextLevel: model.emitLoadNextLevel === true }\n    ) as TreeModel;\n\n    if (isFunction(this.node.loadChildren)) {\n      this._loadChildren = this.node.loadChildren;\n    } else {\n      get(model, 'children', []).forEach((child: TreeModel, index: number) => {\n        this._addChild(new Tree(child, this), index);\n      });\n    }\n\n    if (!Array.isArray(this._children)) {\n      this._children = this.node.loadChildren || isBranch ? [] : null;\n    }\n  }\n\n  public hasDeferredChildren(): boolean {\n    return typeof this._loadChildren === 'function';\n  }\n  /* Setting the children loading state to Loading since a request was dispatched to the client */\n  public loadingChildrenRequested(): void {\n    this._childrenLoadingState = ChildrenLoadingState.Loading;\n  }\n\n  /**\n   * Check whether children of the node are being loaded.\n   * Makes sense only for nodes that define `loadChildren` function.\n   * @returns {boolean} A flag indicating that children are being loaded.\n   */\n  public childrenAreBeingLoaded(): boolean {\n    return this._childrenLoadingState === ChildrenLoadingState.Loading;\n  }\n\n  /**\n   * Check whether children of the node were loaded.\n   * Makes sense only for nodes that define `loadChildren` function.\n   * @returns {boolean} A flag indicating that children were loaded.\n   */\n  public childrenWereLoaded(): boolean {\n    return this._childrenLoadingState === ChildrenLoadingState.Completed;\n  }\n\n  private canLoadChildren(): boolean {\n    return (\n      this._childrenLoadingState === ChildrenLoadingState.NotStarted &&\n      this.foldingType === FoldingType.Expanded &&\n      !!this._loadChildren\n    );\n  }\n\n  /**\n   * Check whether children of the node should be loaded and not loaded yet.\n   * Makes sense only for nodes that define `loadChildren` function.\n   * @returns {boolean} A flag indicating that children should be loaded for the current node.\n   */\n  public childrenShouldBeLoaded(): boolean {\n    return !this.childrenWereLoaded() && (!!this._loadChildren || this.node.emitLoadNextLevel === true);\n  }\n\n  /**\n   * Get children of the current tree.\n   * @returns {Tree[]} The children of the current tree.\n   */\n  public get children(): Tree[] {\n    return this._children;\n  }\n\n  /**\n   * By getting value from this property you start process of loading node's children using `loadChildren` function.\n   * Once children are loaded `loadChildren` function won't be called anymore and loaded for the first time children are emitted in case of subsequent calls.\n   * @returns {Observable<Tree[]>} An observable which emits children once they are loaded.\n   */\n  public get childrenAsync(): Observable<Tree[]> {\n    if (this.canLoadChildren()) {\n      return this._childrenAsyncOnce();\n    }\n    return of(this.children);\n  }\n\n  /**\n   * By calling this method you start process of loading node's children using `loadChildren` function.\n   */\n  public reloadChildren(): void {\n    if (this.childrenShouldBeLoaded()) {\n      this._childrenLoadingState = ChildrenLoadingState.Loading;\n      this._loadChildren((children: TreeModel[]) => {\n        this._children = children && children.map((child: TreeModel) => new Tree(child, this));\n        this._childrenLoadingState = ChildrenLoadingState.Completed;\n      });\n    }\n  }\n\n  /**\n   * By calling this method you will remove all current children of a treee and create new.\n   */\n  public setChildren(children: Array<TreeModel>): void {\n    this._children = children && children.map((child: TreeModel) => new Tree(child, this)