ng-zorro-antd
Version:
An enterprise-class UI components based on Ant Design and Angular
1,738 lines (1,733 loc) • 61.2 kB
JavaScript
import { warnDeprecation } from 'ng-zorro-antd/core/logger';
import { __spread, __values } from 'tslib';
import { Injectable, InjectionToken } from '@angular/core';
import { BehaviorSubject } from 'rxjs';
/**
* @fileoverview added by tsickle
* Generated from: nz-tree-base-node.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function FlattenNode() { }
if (false) {
/** @type {?} */
FlattenNode.prototype.parent;
/** @type {?} */
FlattenNode.prototype.children;
/** @type {?} */
FlattenNode.prototype.pos;
/** @type {?} */
FlattenNode.prototype.data;
/** @type {?} */
FlattenNode.prototype.isStart;
/** @type {?} */
FlattenNode.prototype.isEnd;
}
/**
* @record
*/
function NzTreeNodeOptions() { }
if (false) {
/** @type {?} */
NzTreeNodeOptions.prototype.title;
/** @type {?} */
NzTreeNodeOptions.prototype.key;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.icon;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.isLeaf;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.checked;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.selected;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.selectable;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.disabled;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.disableCheckbox;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.expanded;
/** @type {?|undefined} */
NzTreeNodeOptions.prototype.children;
/* Skipping unhandled member: [key: string]: NzSafeAny;*/
}
var NzTreeNode = /** @class */ (function () {
/**
* Init nzTreeNode
* @param option: user's input
* @param parent
* @param service: base nzTreeService
*/
function NzTreeNode(option, parent, service) {
var _this = this;
if (parent === void 0) { parent = null; }
if (service === void 0) { service = null; }
this.level = 0;
if (option instanceof NzTreeNode) {
return option;
}
this.service = service || null;
this.origin = option;
this.key = option.key;
this.parentNode = parent;
this._title = option.title || '---';
this._icon = option.icon || '';
this._isLeaf = option.isLeaf || false;
this._children = [];
// option params
this._isChecked = option.checked || false;
this._isSelectable = option.disabled || option.selectable !== false;
this._isDisabled = option.disabled || false;
this._isDisableCheckbox = option.disableCheckbox || false;
this._isExpanded = option.isLeaf ? false : option.expanded || false;
this._isHalfChecked = false;
this._isSelected = (!option.disabled && option.selected) || false;
this._isLoading = false;
this.isMatched = false;
/**
* parent's checked status will affect children while initializing
*/
if (parent) {
this.level = parent.level + 1;
}
else {
this.level = 0;
}
if (typeof option.children !== 'undefined' && option.children !== null) {
option.children.forEach((/**
* @param {?} nodeOptions
* @return {?}
*/
function (nodeOptions) {
/** @type {?} */
var s = _this.treeService;
if (s && !s.isCheckStrictly && option.checked && !option.disabled && !nodeOptions.disabled && !nodeOptions.disableCheckbox) {
nodeOptions.checked = option.checked;
}
_this._children.push(new NzTreeNode(nodeOptions, _this));
}));
}
}
Object.defineProperty(NzTreeNode.prototype, "treeService", {
get: /**
* @return {?}
*/
function () {
return this.service || (this.parentNode && this.parentNode.treeService);
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "title", {
/**
* auto generate
* get
* set
*/
get: /**
* auto generate
* get
* set
* @return {?}
*/
function () {
return this._title;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._title = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "icon", {
get: /**
* @return {?}
*/
function () {
return this._icon;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._icon = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "children", {
get: /**
* @return {?}
*/
function () {
return this._children;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._children = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isLeaf", {
get: /**
* @return {?}
*/
function () {
return this._isLeaf;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isLeaf = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isChecked", {
get: /**
* @return {?}
*/
function () {
return this._isChecked;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isChecked = value;
this._isAllChecked = value;
this.origin.checked = value;
this.afterValueChange('isChecked');
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isAllChecked", {
get: /**
* @return {?}
*/
function () {
return this._isAllChecked;
},
/**
* @deprecated Maybe removed in next major version, use `isChecked` instead.
*/
set: /**
* @deprecated Maybe removed in next major version, use `isChecked` instead.
* @param {?} value
* @return {?}
*/
function (value) {
warnDeprecation("'isAllChecked' is going to be removed in 9.0.0. Please use 'isChecked' instead.");
this._isAllChecked = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isHalfChecked", {
get: /**
* @return {?}
*/
function () {
return this._isHalfChecked;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isHalfChecked = value;
this.afterValueChange('isHalfChecked');
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isSelectable", {
get: /**
* @return {?}
*/
function () {
return this._isSelectable;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isSelectable = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isDisabled", {
get: /**
* @return {?}
*/
function () {
return this._isDisabled;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isDisabled = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isDisableCheckbox", {
get: /**
* @return {?}
*/
function () {
return this._isDisableCheckbox;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isDisableCheckbox = value;
this.update();
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isExpanded", {
get: /**
* @return {?}
*/
function () {
return this._isExpanded;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isExpanded = value;
this.origin.expanded = value;
this.afterValueChange('isExpanded');
this.afterValueChange('reRender');
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isSelected", {
get: /**
* @return {?}
*/
function () {
return this._isSelected;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isSelected = value;
this.origin.selected = value;
this.afterValueChange('isSelected');
},
enumerable: true,
configurable: true
});
Object.defineProperty(NzTreeNode.prototype, "isLoading", {
get: /**
* @return {?}
*/
function () {
return this._isLoading;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._isLoading = value;
this.update();
},
enumerable: true,
configurable: true
});
/**
* @param {?=} checked
* @param {?=} halfChecked
* @return {?}
*/
NzTreeNode.prototype.setSyncChecked = /**
* @param {?=} checked
* @param {?=} halfChecked
* @return {?}
*/
function (checked, halfChecked) {
if (checked === void 0) { checked = false; }
if (halfChecked === void 0) { halfChecked = false; }
this.setChecked(checked, halfChecked);
if (this.treeService && !this.treeService.isCheckStrictly) {
this.treeService.conduct(this);
}
};
/**
* @deprecated Maybe removed in next major version, use `isChecked` instead.
*/
/**
* @deprecated Maybe removed in next major version, use `isChecked` instead.
* @param {?=} checked
* @param {?=} halfChecked
* @return {?}
*/
NzTreeNode.prototype.setChecked = /**
* @deprecated Maybe removed in next major version, use `isChecked` instead.
* @param {?=} checked
* @param {?=} halfChecked
* @return {?}
*/
function (checked, halfChecked) {
if (checked === void 0) { checked = false; }
if (halfChecked === void 0) { halfChecked = false; }
warnDeprecation("'setChecked' is going to be removed in 9.0.0. Please use 'isChecked' instead.");
this.origin.checked = checked;
this.isChecked = checked;
this.isAllChecked = checked;
this.isHalfChecked = halfChecked;
};
/**
* @not-deprecated Maybe removed in next major version, use `isExpanded` instead.
* We need it until tree refactoring is finished
*/
/**
* \@not-deprecated Maybe removed in next major version, use `isExpanded` instead.
* We need it until tree refactoring is finished
* @param {?} value
* @return {?}
*/
NzTreeNode.prototype.setExpanded = /**
* \@not-deprecated Maybe removed in next major version, use `isExpanded` instead.
* We need it until tree refactoring is finished
* @param {?} value
* @return {?}
*/
function (value) {
this._isExpanded = value;
this.origin.expanded = value;
this.afterValueChange('isExpanded');
};
/**
* @deprecated Maybe removed in next major version, use `isSelected` instead.
*/
/**
* @deprecated Maybe removed in next major version, use `isSelected` instead.
* @param {?} value
* @return {?}
*/
NzTreeNode.prototype.setSelected = /**
* @deprecated Maybe removed in next major version, use `isSelected` instead.
* @param {?} value
* @return {?}
*/
function (value) {
warnDeprecation("'setSelected' is going to be removed in 9.0.0. Please use 'isExpanded' isSelected.");
if (this.isDisabled) {
return;
}
this.isSelected = value;
};
/**
* @return {?}
*/
NzTreeNode.prototype.getParentNode = /**
* @return {?}
*/
function () {
return this.parentNode;
};
/**
* @return {?}
*/
NzTreeNode.prototype.getChildren = /**
* @return {?}
*/
function () {
return this.children;
};
/**
* Support appending child nodes by position. Leaf node cannot be appended.
*/
/**
* Support appending child nodes by position. Leaf node cannot be appended.
* @param {?} children
* @param {?=} childPos
* @return {?}
*/
NzTreeNode.prototype.addChildren = /**
* Support appending child nodes by position. Leaf node cannot be appended.
* @param {?} children
* @param {?=} childPos
* @return {?}
*/
function (children, childPos) {
var _this = this;
if (childPos === void 0) { childPos = -1; }
if (!this.isLeaf) {
children.forEach((/**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var refreshLevel = (/**
* @param {?} n
* @return {?}
*/
function (n) {
n.getChildren().forEach((/**
* @param {?} c
* @return {?}
*/
function (c) {
c.level = (/** @type {?} */ (c.getParentNode())).level + 1;
// flush origin
c.origin.level = c.level;
refreshLevel(c);
}));
});
/** @type {?} */
var child = node;
if (child instanceof NzTreeNode) {
child.parentNode = _this;
}
else {
child = new NzTreeNode(node, _this);
}
child.level = _this.level + 1;
child.origin.level = child.level;
refreshLevel(child);
try {
childPos === -1 ? _this.children.push(child) : _this.children.splice(childPos, 0, child);
// flush origin
}
catch (e) { }
}));
this.origin.children = this.getChildren().map((/**
* @param {?} v
* @return {?}
*/
function (v) { return v.origin; }));
// remove loading state
this.isLoading = false;
}
this.afterValueChange('addChildren');
this.afterValueChange('reRender');
};
/**
* @return {?}
*/
NzTreeNode.prototype.clearChildren = /**
* @return {?}
*/
function () {
// refresh checked state
this.afterValueChange('clearChildren');
this.children = [];
this.origin.children = [];
this.afterValueChange('reRender');
};
/**
* @return {?}
*/
NzTreeNode.prototype.remove = /**
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var parentNode = this.getParentNode();
if (parentNode) {
parentNode.children = parentNode.getChildren().filter((/**
* @param {?} v
* @return {?}
*/
function (v) { return v.key !== _this.key; }));
parentNode.origin.children = (/** @type {?} */ (parentNode.origin.children)).filter((/**
* @param {?} v
* @return {?}
*/
function (v) { return v.key !== _this.key; }));
this.afterValueChange('remove');
this.afterValueChange('reRender');
}
};
/**
* @param {?} key
* @return {?}
*/
NzTreeNode.prototype.afterValueChange = /**
* @param {?} key
* @return {?}
*/
function (key) {
if (this.treeService) {
switch (key) {
case 'isChecked':
this.treeService.setCheckedNodeList(this);
break;
case 'isHalfChecked':
this.treeService.setHalfCheckedNodeList(this);
break;
case 'isExpanded':
this.treeService.setExpandedNodeList(this);
break;
case 'isSelected':
this.treeService.setNodeActive(this);
break;
case 'clearChildren':
this.treeService.afterRemove(this.getChildren());
break;
case 'remove':
this.treeService.afterRemove([this]);
break;
case 'reRender':
this.treeService.flattenTreeData(this.treeService.rootNodes, this.treeService.getExpandedNodeList().map((/**
* @param {?} v
* @return {?}
*/
function (v) { return v.key; })));
break;
}
}
this.update();
};
/**
* @return {?}
*/
NzTreeNode.prototype.update = /**
* @return {?}
*/
function () {
if (this.component) {
this.component.markForCheck();
}
};
return NzTreeNode;
}());
if (false) {
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._title;
/** @type {?} */
NzTreeNode.prototype.key;
/** @type {?} */
NzTreeNode.prototype.level;
/** @type {?} */
NzTreeNode.prototype.origin;
/** @type {?} */
NzTreeNode.prototype.parentNode;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._icon;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._children;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isLeaf;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isChecked;
/**
* @deprecated Maybe removed in next major version, use isChecked instead
* @type {?}
* @private
*/
NzTreeNode.prototype._isAllChecked;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isSelectable;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isDisabled;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isDisableCheckbox;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isExpanded;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isHalfChecked;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isSelected;
/**
* @type {?}
* @private
*/
NzTreeNode.prototype._isLoading;
/** @type {?} */
NzTreeNode.prototype.canHide;
/** @type {?} */
NzTreeNode.prototype.isMatched;
/** @type {?} */
NzTreeNode.prototype.service;
/** @type {?} */
NzTreeNode.prototype.component;
/**
* New added in Tree for easy data access
* @type {?}
*/
NzTreeNode.prototype.isStart;
/** @type {?} */
NzTreeNode.prototype.isEnd;
}
/**
* @fileoverview added by tsickle
* Generated from: nz-tree-base.definitions.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Alibaba.com All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
*/
/**
* @record
*/
function NzFormatEmitEvent() { }
if (false) {
/** @type {?} */
NzFormatEmitEvent.prototype.eventName;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.node;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.event;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.dragNode;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.selectedKeys;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.checkedKeys;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.matchedKeys;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.nodes;
/** @type {?|undefined} */
NzFormatEmitEvent.prototype.keys;
}
/**
* @record
*/
function NzFormatBeforeDropEvent() { }
if (false) {
/** @type {?} */
NzFormatBeforeDropEvent.prototype.dragNode;
/** @type {?} */
NzFormatBeforeDropEvent.prototype.node;
/** @type {?} */
NzFormatBeforeDropEvent.prototype.pos;
}
/**
* @record
*/
function NzTreeNodeBaseComponent() { }
if (false) {
/**
* @return {?}
*/
NzTreeNodeBaseComponent.prototype.markForCheck = function () { };
}
/**
* @fileoverview added by tsickle
* Generated from: nz-tree-base-util.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Alibaba.com All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
*/
/**
* @param {?} node
* @return {?}
*/
function isCheckDisabled(node) {
var isDisabled = node.isDisabled, isDisableCheckbox = node.isDisableCheckbox;
return !!(isDisabled || isDisableCheckbox);
}
/**
* @param {?} needle
* @param {?} haystack
* @return {?}
*/
function isInArray(needle, haystack) {
return haystack.length > 0 && haystack.indexOf(needle) > -1;
}
/**
* @param {?} level
* @param {?} index
* @return {?}
*/
function getPosition(level, index) {
return level + "-" + index;
}
/**
* @param {?} key
* @param {?} pos
* @return {?}
*/
function getKey(key, pos) {
if (key !== null && key !== undefined) {
return key;
}
return pos;
}
/**
* Flat nest tree data into flatten list. This is used for virtual list render.
* @param {?=} treeNodeList Origin data node list
* @param {?=} expandedKeys
* need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
* @return {?}
*/
function flattenTreeData(treeNodeList, expandedKeys) {
if (treeNodeList === void 0) { treeNodeList = []; }
if (expandedKeys === void 0) { expandedKeys = []; }
/** @type {?} */
var expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
/** @type {?} */
var flattenList = [];
/**
* @param {?} list
* @param {?=} parent
* @return {?}
*/
function dig(list, parent) {
if (parent === void 0) { parent = null; }
return list.map((/**
* @param {?} treeNode
* @param {?} index
* @return {?}
*/
function (treeNode, index) {
/** @type {?} */
var pos = getPosition(parent ? parent.pos : '0', index);
/** @type {?} */
var mergedKey = getKey(treeNode.key, pos);
treeNode.isStart = __spread((parent ? parent.isStart : []), [index === 0]);
treeNode.isEnd = __spread((parent ? parent.isEnd : []), [index === list.length - 1]);
// Add FlattenDataNode into list
// TODO: only need data here.
/** @type {?} */
var flattenNode = {
parent: parent,
pos: pos,
children: [],
data: treeNode,
isStart: __spread((parent ? parent.isStart : []), [index === 0]),
isEnd: __spread((parent ? parent.isEnd : []), [index === list.length - 1])
};
flattenList.push(flattenNode);
// Loop treeNode children
if (expandedKeys === true || expandedKeySet.has(mergedKey) || treeNode.isExpanded) {
flattenNode.children = dig(treeNode.children || [], flattenNode);
}
else {
flattenNode.children = [];
}
return flattenNode;
}));
}
dig(treeNodeList);
return flattenList;
}
/**
* @fileoverview added by tsickle
* Generated from: nz-tree-base.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var NzTreeBaseService = /** @class */ (function () {
function NzTreeBaseService() {
this.DRAG_SIDE_RANGE = 0.25;
this.DRAG_MIN_GAP = 2;
this.isCheckStrictly = false;
this.isMultiple = false;
this.rootNodes = [];
this.flattenNodes$ = new BehaviorSubject([]);
this.selectedNodeList = [];
this.expandedNodeList = [];
this.checkedNodeList = [];
this.halfCheckedNodeList = [];
this.matchedNodeList = [];
}
/**
* reset tree nodes will clear default node list
*/
/**
* reset tree nodes will clear default node list
* @param {?} nzNodes
* @return {?}
*/
NzTreeBaseService.prototype.initTree = /**
* reset tree nodes will clear default node list
* @param {?} nzNodes
* @return {?}
*/
function (nzNodes) {
this.rootNodes = nzNodes;
this.expandedNodeList = [];
this.selectedNodeList = [];
this.halfCheckedNodeList = [];
this.checkedNodeList = [];
this.matchedNodeList = [];
};
/**
* @param {?} nzNodes
* @param {?=} expandedKeys
* @return {?}
*/
NzTreeBaseService.prototype.flattenTreeData = /**
* @param {?} nzNodes
* @param {?=} expandedKeys
* @return {?}
*/
function (nzNodes, expandedKeys) {
if (expandedKeys === void 0) { expandedKeys = []; }
this.flattenNodes$.next(flattenTreeData(nzNodes, expandedKeys).map((/**
* @param {?} item
* @return {?}
*/
function (item) { return item.data; })));
};
/**
* @return {?}
*/
NzTreeBaseService.prototype.getSelectedNode = /**
* @return {?}
*/
function () {
return this.selectedNode;
};
/**
* get some list
*/
/**
* get some list
* @return {?}
*/
NzTreeBaseService.prototype.getSelectedNodeList = /**
* get some list
* @return {?}
*/
function () {
return this.conductNodeState('select');
};
/**
* return checked nodes
*/
/**
* return checked nodes
* @return {?}
*/
NzTreeBaseService.prototype.getCheckedNodeList = /**
* return checked nodes
* @return {?}
*/
function () {
return this.conductNodeState('check');
};
/**
* @return {?}
*/
NzTreeBaseService.prototype.getHalfCheckedNodeList = /**
* @return {?}
*/
function () {
return this.conductNodeState('halfCheck');
};
/**
* return expanded nodes
*/
/**
* return expanded nodes
* @return {?}
*/
NzTreeBaseService.prototype.getExpandedNodeList = /**
* return expanded nodes
* @return {?}
*/
function () {
return this.conductNodeState('expand');
};
/**
* return search matched nodes
*/
/**
* return search matched nodes
* @return {?}
*/
NzTreeBaseService.prototype.getMatchedNodeList = /**
* return search matched nodes
* @return {?}
*/
function () {
return this.conductNodeState('match');
};
/**
* @param {?} value
* @return {?}
*/
NzTreeBaseService.prototype.isArrayOfNzTreeNode = /**
* @param {?} value
* @return {?}
*/
function (value) {
return value.every((/**
* @param {?} item
* @return {?}
*/
function (item) { return item instanceof NzTreeNode; }));
};
/**
* set drag node
*/
/**
* set drag node
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.setSelectedNode = /**
* set drag node
* @param {?} node
* @return {?}
*/
function (node) {
this.selectedNode = node;
};
/**
* set node selected status
*/
/**
* set node selected status
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.setNodeActive = /**
* set node selected status
* @param {?} node
* @return {?}
*/
function (node) {
if (!this.isMultiple && node.isSelected) {
this.selectedNodeList.forEach((/**
* @param {?} n
* @return {?}
*/
function (n) {
if (node.key !== n.key) {
// reset other nodes
n.isSelected = false;
}
}));
// single mode: remove pre node
this.selectedNodeList = [];
}
this.setSelectedNodeList(node, this.isMultiple);
};
/**
* add or remove node to selectedNodeList
*/
/**
* add or remove node to selectedNodeList
* @param {?} node
* @param {?=} isMultiple
* @return {?}
*/
NzTreeBaseService.prototype.setSelectedNodeList = /**
* add or remove node to selectedNodeList
* @param {?} node
* @param {?=} isMultiple
* @return {?}
*/
function (node, isMultiple) {
if (isMultiple === void 0) { isMultiple = false; }
/** @type {?} */
var index = this.getIndexOfArray(this.selectedNodeList, node.key);
if (isMultiple) {
if (node.isSelected && index === -1) {
this.selectedNodeList.push(node);
}
}
else {
if (node.isSelected && index === -1) {
this.selectedNodeList = [node];
}
}
if (!node.isSelected) {
this.selectedNodeList = this.selectedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key !== node.key; }));
}
};
/**
* merge checked nodes
*/
/**
* merge checked nodes
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.setHalfCheckedNodeList = /**
* merge checked nodes
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var index = this.getIndexOfArray(this.halfCheckedNodeList, node.key);
if (node.isHalfChecked && index === -1) {
this.halfCheckedNodeList.push(node);
}
else if (!node.isHalfChecked && index > -1) {
this.halfCheckedNodeList = this.halfCheckedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return node.key !== n.key; }));
}
};
/**
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.setCheckedNodeList = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var index = this.getIndexOfArray(this.checkedNodeList, node.key);
if (node.isChecked && index === -1) {
this.checkedNodeList.push(node);
}
else if (!node.isChecked && index > -1) {
this.checkedNodeList = this.checkedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return node.key !== n.key; }));
}
};
/**
* conduct checked/selected/expanded keys
*/
/**
* conduct checked/selected/expanded keys
* @param {?=} type
* @return {?}
*/
NzTreeBaseService.prototype.conductNodeState = /**
* conduct checked/selected/expanded keys
* @param {?=} type
* @return {?}
*/
function (type) {
var _this = this;
if (type === void 0) { type = 'check'; }
/** @type {?} */
var resultNodesList = [];
switch (type) {
case 'select':
resultNodesList = this.selectedNodeList;
break;
case 'expand':
resultNodesList = this.expandedNodeList;
break;
case 'match':
resultNodesList = this.matchedNodeList;
break;
case 'check':
resultNodesList = this.checkedNodeList;
/** @type {?} */
var isIgnore_1 = (/**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var parentNode = node.getParentNode();
if (parentNode) {
if (_this.checkedNodeList.findIndex((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key === parentNode.key; })) > -1) {
return true;
}
else {
return isIgnore_1(parentNode);
}
}
return false;
});
// merge checked
if (!this.isCheckStrictly) {
resultNodesList = this.checkedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return !isIgnore_1(n); }));
}
break;
case 'halfCheck':
if (!this.isCheckStrictly) {
resultNodesList = this.halfCheckedNodeList;
}
break;
}
return resultNodesList;
};
/**
* set expanded nodes
*/
/**
* set expanded nodes
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.setExpandedNodeList = /**
* set expanded nodes
* @param {?} node
* @return {?}
*/
function (node) {
if (node.isLeaf) {
return;
}
/** @type {?} */
var index = this.getIndexOfArray(this.expandedNodeList, node.key);
if (node.isExpanded && index === -1) {
this.expandedNodeList.push(node);
}
else if (!node.isExpanded && index > -1) {
this.expandedNodeList.splice(index, 1);
}
};
/**
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.setMatchedNodeList = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var index = this.getIndexOfArray(this.matchedNodeList, node.key);
if (node.isMatched && index === -1) {
this.matchedNodeList.push(node);
}
else if (!node.isMatched && index > -1) {
this.matchedNodeList.splice(index, 1);
}
};
/**
* check state
* @param isCheckStrictly
*/
/**
* check state
* @param {?=} isCheckStrictly
* @return {?}
*/
NzTreeBaseService.prototype.refreshCheckState = /**
* check state
* @param {?=} isCheckStrictly
* @return {?}
*/
function (isCheckStrictly) {
var _this = this;
if (isCheckStrictly === void 0) { isCheckStrictly = false; }
if (isCheckStrictly) {
return;
}
this.checkedNodeList.forEach((/**
* @param {?} node
* @return {?}
*/
function (node) {
_this.conduct(node);
}));
};
// reset other node checked state based current node
// reset other node checked state based current node
/**
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.conduct =
// reset other node checked state based current node
/**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var isChecked = node.isChecked;
if (node) {
this.conductUp(node);
this.conductDown(node, isChecked);
}
};
/**
* 1、children half checked
* 2、children all checked, parent checked
* 3、no children checked
*/
/**
* 1、children half checked
* 2、children all checked, parent checked
* 3、no children checked
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.conductUp = /**
* 1、children half checked
* 2、children all checked, parent checked
* 3、no children checked
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var parentNode = node.getParentNode();
if (parentNode) {
if (!isCheckDisabled(parentNode)) {
if (parentNode.children.every((/**
* @param {?} child
* @return {?}
*/
function (child) { return isCheckDisabled(child) || (!child.isHalfChecked && child.isChecked); }))) {
parentNode.isChecked = true;
parentNode.isHalfChecked = false;
}
else if (parentNode.children.some((/**
* @param {?} child
* @return {?}
*/
function (child) { return child.isHalfChecked || child.isChecked; }))) {
parentNode.isChecked = false;
parentNode.isHalfChecked = true;
}
else {
parentNode.isChecked = false;
parentNode.isHalfChecked = false;
}
}
this.setCheckedNodeList(parentNode);
this.setHalfCheckedNodeList(parentNode);
this.conductUp(parentNode);
}
};
/**
* reset child check state
*/
/**
* reset child check state
* @param {?} node
* @param {?} value
* @return {?}
*/
NzTreeBaseService.prototype.conductDown = /**
* reset child check state
* @param {?} node
* @param {?} value
* @return {?}
*/
function (node, value) {
var _this = this;
if (!isCheckDisabled(node)) {
node.isChecked = value;
node.isHalfChecked = false;
this.setCheckedNodeList(node);
this.setHalfCheckedNodeList(node);
node.children.forEach((/**
* @param {?} n
* @return {?}
*/
function (n) {
_this.conductDown(n, value);
}));
}
};
/**
* flush after delete node
*/
/**
* flush after delete node
* @param {?} nodes
* @return {?}
*/
NzTreeBaseService.prototype.afterRemove = /**
* flush after delete node
* @param {?} nodes
* @return {?}
*/
function (nodes) {
var _this = this;
// to reset selectedNodeList & expandedNodeList
/** @type {?} */
var loopNode = (/**
* @param {?} node
* @return {?}
*/
function (node) {
// remove selected node
_this.selectedNodeList = _this.selectedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key !== node.key; }));
// remove expanded node
_this.expandedNodeList = _this.expandedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key !== node.key; }));
// remove checked node
_this.checkedNodeList = _this.checkedNodeList.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key !== node.key; }));
if (node.children) {
node.children.forEach((/**
* @param {?} child
* @return {?}
*/
function (child) {
loopNode(child);
}));
}
});
nodes.forEach((/**
* @param {?} n
* @return {?}
*/
function (n) {
loopNode(n);
}));
this.refreshCheckState(this.isCheckStrictly);
};
/**
* drag event
*/
/**
* drag event
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.refreshDragNode = /**
* drag event
* @param {?} node
* @return {?}
*/
function (node) {
var _this = this;
if (node.children.length === 0) {
// until root
this.conductUp(node);
}
else {
node.children.forEach((/**
* @param {?} child
* @return {?}
*/
function (child) {
_this.refreshDragNode(child);
}));
}
};
// reset node level
// reset node level
/**
* @param {?} node
* @return {?}
*/
NzTreeBaseService.prototype.resetNodeLevel =
// reset node level
/**
* @param {?} node
* @return {?}
*/
function (node) {
var e_1, _a;
/** @type {?} */
var parentNode = node.getParentNode();
if (parentNode) {
node.level = parentNode.level + 1;
}
else {
node.level = 0;
}
try {
for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
var child = _c.value;
this.resetNodeLevel(child);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
};
/**
* @param {?} event
* @return {?}
*/
NzTreeBaseService.prototype.calcDropPosition = /**
* @param {?} event
* @return {?}
*/
function (event) {
var clientY = event.clientY;
// to fix firefox undefined
var _a = event.srcElement
? ((/** @type {?} */ (event.srcElement))).getBoundingClientRect()
: ((/** @type {?} */ (event.target))).getBoundingClientRect(), top = _a.top, bottom = _a.bottom, height = _a.height;
/** @type {?} */
var des = Math.max(height * this.DRAG_SIDE_RANGE, this.DRAG_MIN_GAP);
if (clientY <= top + des) {
return -1;
}
else if (clientY >= bottom - des) {
return 1;
}
return 0;
};
/**
* drop
* 0: inner -1: pre 1: next
*/
/**
* drop
* 0: inner -1: pre 1: next
* @param {?} targetNode
* @param {?=} dragPos
* @return {?}
*/
NzTreeBaseService.prototype.dropAndApply = /**
* drop
* 0: inner -1: pre 1: next
* @param {?} targetNode
* @param {?=} dragPos
* @return {?}
*/
function (targetNode, dragPos) {
var _this = this;
if (dragPos === void 0) { dragPos = -1; }
if (!targetNode || dragPos > 1) {
return;
}
/** @type {?} */
var treeService = targetNode.treeService;
/** @type {?} */
var targetParent = targetNode.getParentNode();
/** @type {?} */
var isSelectedRootNode = this.selectedNode.getParentNode();
// remove the dragNode
if (isSelectedRootNode) {
isSelectedRootNode.children = isSelectedRootNode.children.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key !== _this.selectedNode.key; }));
}
else {
this.rootNodes = this.rootNodes.filter((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key !== _this.selectedNode.key; }));
}
switch (dragPos) {
case 0:
targetNode.addChildren([this.selectedNode]);
this.resetNodeLevel(targetNode);
break;
case -1:
case 1:
/** @type {?} */
var tIndex = dragPos === 1 ? 1 : 0;
if (targetParent) {
targetParent.addChildren([this.selectedNode], targetParent.children.indexOf(targetNode) + tIndex);
/** @type {?} */
var parentNode = this.selectedNode.getParentNode();
if (parentNode) {
this.resetNodeLevel(parentNode);
}
}
else {
/** @type {?} */
var targetIndex = this.rootNodes.indexOf(targetNode) + tIndex;
// Insert root node.
this.rootNodes.splice(targetIndex, 0, this.selectedNode);
this.rootNodes[targetIndex].parentNode = null;
this.resetNodeLevel(this.rootNodes[targetIndex]);
}
break;
}
// flush all nodes
this.rootNodes.forEach((/**
* @param {?} child
* @return {?}
*/
function (child) {
if (!child.treeService) {
child.service = treeService;
}
_this.refreshDragNode(child);
}));
};
/**
* emit Structure
* eventName
* node
* event: MouseEvent / DragEvent
* dragNode
*/
/**
* emit Structure
* eventName
* node
* event: MouseEvent / DragEvent
* dragNode
* @param {?} eventName
* @param {?} node
* @param {?} event
* @return {?}
*/
NzTreeBaseService.prototype.formatEvent = /**
* emit Structure
* eventName
* node
* event: MouseEvent / DragEvent
* dragNode
* @param {?} eventName
* @param {?} node
* @param {?} event
* @return {?}
*/
function (eventName, node, event) {
/** @type {?} */
var emitStructure = {
eventName: eventName,
node: node,
event: event
};
switch (eventName) {
case 'dragstart':
case 'dragenter':
case 'dragover':
case 'dragleave':
case 'drop':
case 'dragend':
Object.assign(emitStructure, { dragNode: this.getSelectedNode() });
break;
case 'click':
case 'dblclick':
Object.assign(emitStructure, { selectedKeys: this.selectedNodeList });
Object.assign(emitStructure, { nodes: this.selectedNodeList });
Object.assign(emitStructure, { keys: this.selectedNodeList.map((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key; })) });
break;
case 'check':
/** @type {?} */
var checkedNodeList = this.getCheckedNodeList();
Object.assign(emitStructure, { checkedKeys: checkedNodeList });
Object.assign(emitStructure, { nodes: checkedNodeList });
Object.assign(emitStructure, { keys: checkedNodeList.map((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key; })) });
break;
case 'search':
Object.assign(emitStructure, { matchedKeys: this.getMatchedNodeList() });
Object.assign(emitStructure, { nodes: this.getMatchedNodeList() });
Object.assign(emitStructure, { keys: this.getMatchedNodeList().map((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key; })) });
break;
case 'expand':
Object.assign(emitStructure, { nodes: this.expandedNodeList });
Object.assign(emitStructure, { keys: this.expandedNodeList.map((/**
* @param {?} n
* @return {?}
*/
function (n) { return n.key; })) });
break;
}
return emitStructure;
};
/**
* New functions for flatten nodes
*/
/**
* New functions for flatten nodes