UNPKG

ng-zorro-antd

Version:

An enterprise-class UI components based on Ant Design and Angular

1,738 lines (1,733 loc) 61.2 kB
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