'use strict';
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
var vue = require('vue');
|
var util = require('../util.js');
|
|
function useTree(watcherData) {
|
const expandRowKeys = vue.ref([]);
|
const treeData = vue.ref({});
|
const indent = vue.ref(16);
|
const lazy = vue.ref(false);
|
const lazyTreeNodeMap = vue.ref({});
|
const lazyColumnIdentifier = vue.ref("hasChildren");
|
const childrenColumnName = vue.ref("children");
|
const instance = vue.getCurrentInstance();
|
const normalizedData = vue.computed(() => {
|
if (!watcherData.rowKey.value)
|
return {};
|
const data = watcherData.data.value || [];
|
return normalize(data);
|
});
|
const normalizedLazyNode = vue.computed(() => {
|
const rowKey = watcherData.rowKey.value;
|
const keys = Object.keys(lazyTreeNodeMap.value);
|
const res = {};
|
if (!keys.length)
|
return res;
|
keys.forEach((key) => {
|
if (lazyTreeNodeMap.value[key].length) {
|
const item = { children: [] };
|
lazyTreeNodeMap.value[key].forEach((row) => {
|
const currentRowKey = util.getRowIdentity(row, rowKey);
|
item.children.push(currentRowKey);
|
if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
|
res[currentRowKey] = { children: [] };
|
}
|
});
|
res[key] = item;
|
}
|
});
|
return res;
|
});
|
const normalize = (data) => {
|
const rowKey = watcherData.rowKey.value;
|
const res = {};
|
util.walkTreeNode(data, (parent, children, level) => {
|
const parentId = util.getRowIdentity(parent, rowKey);
|
if (Array.isArray(children)) {
|
res[parentId] = {
|
children: children.map((row) => util.getRowIdentity(row, rowKey)),
|
level
|
};
|
} else if (lazy.value) {
|
res[parentId] = {
|
children: [],
|
lazy: true,
|
level
|
};
|
}
|
}, childrenColumnName.value, lazyColumnIdentifier.value);
|
return res;
|
};
|
const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll = ((_a) => (_a = instance.store) == null ? void 0 : _a.states.defaultExpandAll.value)()) => {
|
var _a2;
|
const nested = normalizedData.value;
|
const normalizedLazyNode_ = normalizedLazyNode.value;
|
const keys = Object.keys(nested);
|
const newTreeData = {};
|
if (keys.length) {
|
const oldTreeData = vue.unref(treeData);
|
const rootLazyRowKeys = [];
|
const getExpanded = (oldValue, key) => {
|
if (ifChangeExpandRowKeys) {
|
if (expandRowKeys.value) {
|
return ifExpandAll || expandRowKeys.value.includes(key);
|
} else {
|
return !!(ifExpandAll || (oldValue == null ? void 0 : oldValue.expanded));
|
}
|
} else {
|
const included = ifExpandAll || expandRowKeys.value && expandRowKeys.value.includes(key);
|
return !!((oldValue == null ? void 0 : oldValue.expanded) || included);
|
}
|
};
|
keys.forEach((key) => {
|
const oldValue = oldTreeData[key];
|
const newValue = { ...nested[key] };
|
newValue.expanded = getExpanded(oldValue, key);
|
if (newValue.lazy) {
|
const { loaded = false, loading = false } = oldValue || {};
|
newValue.loaded = !!loaded;
|
newValue.loading = !!loading;
|
rootLazyRowKeys.push(key);
|
}
|
newTreeData[key] = newValue;
|
});
|
const lazyKeys = Object.keys(normalizedLazyNode_);
|
if (lazy.value && lazyKeys.length && rootLazyRowKeys.length) {
|
lazyKeys.forEach((key) => {
|
const oldValue = oldTreeData[key];
|
const lazyNodeChildren = normalizedLazyNode_[key].children;
|
if (rootLazyRowKeys.includes(key)) {
|
if (newTreeData[key].children.length !== 0) {
|
throw new Error("[ElTable]children must be an empty array.");
|
}
|
newTreeData[key].children = lazyNodeChildren;
|
} else {
|
const { loaded = false, loading = false } = oldValue || {};
|
newTreeData[key] = {
|
lazy: true,
|
loaded: !!loaded,
|
loading: !!loading,
|
expanded: getExpanded(oldValue, key),
|
children: lazyNodeChildren,
|
level: ""
|
};
|
}
|
});
|
}
|
}
|
treeData.value = newTreeData;
|
(_a2 = instance.store) == null ? void 0 : _a2.updateTableScrollY();
|
};
|
vue.watch(() => expandRowKeys.value, () => {
|
updateTreeData(true);
|
});
|
vue.watch(() => normalizedData.value, () => {
|
updateTreeData();
|
});
|
vue.watch(() => normalizedLazyNode.value, () => {
|
updateTreeData();
|
});
|
const updateTreeExpandKeys = (value) => {
|
expandRowKeys.value = value;
|
updateTreeData();
|
};
|
const toggleTreeExpansion = (row, expanded) => {
|
instance.store.assertRowKey();
|
const rowKey = watcherData.rowKey.value;
|
const id = util.getRowIdentity(row, rowKey);
|
const data = id && treeData.value[id];
|
if (id && data && "expanded" in data) {
|
const oldExpanded = data.expanded;
|
expanded = typeof expanded === "undefined" ? !data.expanded : expanded;
|
treeData.value[id].expanded = expanded;
|
if (oldExpanded !== expanded) {
|
instance.emit("expand-change", row, expanded);
|
}
|
instance.store.updateTableScrollY();
|
}
|
};
|
const loadOrToggle = (row) => {
|
instance.store.assertRowKey();
|
const rowKey = watcherData.rowKey.value;
|
const id = util.getRowIdentity(row, rowKey);
|
const data = treeData.value[id];
|
if (lazy.value && data && "loaded" in data && !data.loaded) {
|
loadData(row, id, data);
|
} else {
|
toggleTreeExpansion(row, void 0);
|
}
|
};
|
const loadData = (row, key, treeNode) => {
|
const { load } = instance.props;
|
if (load && !treeData.value[key].loaded) {
|
treeData.value[key].loading = true;
|
load(row, treeNode, (data) => {
|
if (!Array.isArray(data)) {
|
throw new TypeError("[ElTable] data must be an array");
|
}
|
treeData.value[key].loading = false;
|
treeData.value[key].loaded = true;
|
treeData.value[key].expanded = true;
|
if (data.length) {
|
lazyTreeNodeMap.value[key] = data;
|
}
|
instance.emit("expand-change", row, true);
|
});
|
}
|
};
|
return {
|
loadData,
|
loadOrToggle,
|
toggleTreeExpansion,
|
updateTreeExpandKeys,
|
updateTreeData,
|
normalize,
|
states: {
|
expandRowKeys,
|
treeData,
|
indent,
|
lazy,
|
lazyTreeNodeMap,
|
lazyColumnIdentifier,
|
childrenColumnName
|
}
|
};
|
}
|
|
exports["default"] = useTree;
|
//# sourceMappingURL=tree.js.map
|
