增加admin管理帐号和项目的界面--初步实现
This commit is contained in:
Cheng Zhou
+63
@@ -0,0 +1,63 @@
|
||||
import type TreeStore from './tree-store';
|
||||
import type { Nullable } from 'element-plus/es/utils';
|
||||
import type { FakeNode, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from '../tree.type';
|
||||
export declare const getChildState: (node: Node[]) => TreeNodeChildState;
|
||||
declare class Node {
|
||||
id: number;
|
||||
text: string | null;
|
||||
checked: boolean;
|
||||
indeterminate: boolean;
|
||||
data: TreeNodeData;
|
||||
expanded: boolean;
|
||||
parent: Node | null;
|
||||
visible: boolean;
|
||||
isCurrent: boolean;
|
||||
store: TreeStore;
|
||||
isLeafByUser: boolean | undefined;
|
||||
isLeaf: boolean | undefined;
|
||||
canFocus: boolean;
|
||||
level: number;
|
||||
loaded: boolean;
|
||||
childNodes: Node[];
|
||||
loading: boolean;
|
||||
/**
|
||||
* Determines whether the current tree node is effectively checked.
|
||||
*
|
||||
* Rules:
|
||||
* 1. A disabled leaf node is always considered checked.
|
||||
* 2. A non-disabled leaf node reflects its actual checked state.
|
||||
* 3. A non-leaf node is considered checked only when:
|
||||
* - All of its child nodes are effectively checked, and
|
||||
* - Each child follows the same evaluation rules:
|
||||
* - Disabled leaf nodes follow rule #1.
|
||||
* - Non-leaf child nodes are recursively evaluated under this rule (#3).
|
||||
*/
|
||||
isEffectivelyChecked: boolean;
|
||||
constructor(options: TreeNodeOptions);
|
||||
initialize(): void;
|
||||
setData(data: TreeNodeData): void;
|
||||
get label(): string;
|
||||
get key(): TreeKey | null | undefined;
|
||||
get disabled(): boolean;
|
||||
get nextSibling(): Nullable<Node>;
|
||||
get previousSibling(): Nullable<Node>;
|
||||
contains(target: Node, deep?: boolean): boolean;
|
||||
remove(): void;
|
||||
insertChild(child?: FakeNode | Node, index?: number, batch?: boolean): void;
|
||||
insertBefore(child: FakeNode | Node, ref: Node): void;
|
||||
insertAfter(child: FakeNode | Node, ref: Node): void;
|
||||
removeChild(child: Node): void;
|
||||
removeChildByData(data: TreeNodeData | null): void;
|
||||
expand(callback?: (() => void) | null, expandParent?: boolean): void;
|
||||
doCreateChildren(array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps): void;
|
||||
collapse(): void;
|
||||
shouldLoadData(): boolean;
|
||||
updateLeafState(): void;
|
||||
setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void;
|
||||
getChildren(forceInit?: boolean): TreeNodeData | TreeNodeData[] | null;
|
||||
updateChildren(): void;
|
||||
loadData(callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps): void;
|
||||
eachNode(callback: (node: Node) => void): void;
|
||||
reInitChecked(): void;
|
||||
}
|
||||
export default Node;
|
||||
+462
@@ -0,0 +1,462 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var vue = require('vue');
|
||||
var lodashUnified = require('lodash-unified');
|
||||
var util = require('./util.js');
|
||||
var shared = require('@vue/shared');
|
||||
var types = require('../../../../utils/types.js');
|
||||
|
||||
const getChildState = (node) => {
|
||||
let all = true;
|
||||
let none = true;
|
||||
let allWithoutDisable = true;
|
||||
let isEffectivelyChecked = true;
|
||||
for (let i = 0, j = node.length; i < j; i++) {
|
||||
const n = node[i];
|
||||
if (n.checked !== true || n.indeterminate) {
|
||||
all = false;
|
||||
if (!n.disabled) {
|
||||
allWithoutDisable = false;
|
||||
}
|
||||
}
|
||||
if (n.checked !== false || n.indeterminate) {
|
||||
none = false;
|
||||
}
|
||||
if (!n.isEffectivelyChecked) {
|
||||
isEffectivelyChecked = false;
|
||||
}
|
||||
}
|
||||
return {
|
||||
all,
|
||||
none,
|
||||
allWithoutDisable,
|
||||
half: !all && !none,
|
||||
isEffectivelyChecked
|
||||
};
|
||||
};
|
||||
const reInitChecked = function(node) {
|
||||
if (node.childNodes.length === 0 || node.loading) {
|
||||
node.isEffectivelyChecked = node.disabled || node.checked;
|
||||
return;
|
||||
}
|
||||
const { all, none, half, isEffectivelyChecked } = getChildState(node.childNodes);
|
||||
node.isEffectivelyChecked = isEffectivelyChecked;
|
||||
if (all) {
|
||||
node.checked = true;
|
||||
node.indeterminate = false;
|
||||
} else if (half) {
|
||||
node.checked = false;
|
||||
node.indeterminate = true;
|
||||
} else if (none) {
|
||||
node.checked = false;
|
||||
node.indeterminate = false;
|
||||
}
|
||||
const parent = node.parent;
|
||||
if (!parent || parent.level === 0)
|
||||
return;
|
||||
if (!node.store.checkStrictly) {
|
||||
reInitChecked(parent);
|
||||
}
|
||||
};
|
||||
const getPropertyFromData = function(node, prop) {
|
||||
const props = node.store.props;
|
||||
const data = node.data || {};
|
||||
const config = props[prop];
|
||||
if (shared.isFunction(config)) {
|
||||
return config(data, node);
|
||||
} else if (shared.isString(config)) {
|
||||
return data[config];
|
||||
} else if (types.isUndefined(config)) {
|
||||
const dataProp = data[prop];
|
||||
return types.isUndefined(dataProp) ? "" : dataProp;
|
||||
}
|
||||
};
|
||||
const setCanFocus = function(childNodes, focus) {
|
||||
childNodes.forEach((item) => {
|
||||
item.canFocus = focus;
|
||||
setCanFocus(item.childNodes, focus);
|
||||
});
|
||||
};
|
||||
let nodeIdSeed = 0;
|
||||
class Node {
|
||||
constructor(options) {
|
||||
this.isLeafByUser = void 0;
|
||||
this.isLeaf = void 0;
|
||||
this.isEffectivelyChecked = false;
|
||||
this.id = nodeIdSeed++;
|
||||
this.text = null;
|
||||
this.checked = false;
|
||||
this.indeterminate = false;
|
||||
this.data = null;
|
||||
this.expanded = false;
|
||||
this.parent = null;
|
||||
this.visible = true;
|
||||
this.isCurrent = false;
|
||||
this.canFocus = false;
|
||||
for (const name in options) {
|
||||
if (shared.hasOwn(options, name)) {
|
||||
this[name] = options[name];
|
||||
}
|
||||
}
|
||||
this.level = 0;
|
||||
this.loaded = false;
|
||||
this.childNodes = [];
|
||||
this.loading = false;
|
||||
if (this.parent) {
|
||||
this.level = this.parent.level + 1;
|
||||
}
|
||||
}
|
||||
initialize() {
|
||||
var _a;
|
||||
const store = this.store;
|
||||
if (!store) {
|
||||
throw new Error("[Node]store is required!");
|
||||
}
|
||||
store.registerNode(this);
|
||||
const props = store.props;
|
||||
if (props && typeof props.isLeaf !== "undefined") {
|
||||
const isLeaf = getPropertyFromData(this, "isLeaf");
|
||||
if (types.isBoolean(isLeaf)) {
|
||||
this.isLeafByUser = isLeaf;
|
||||
}
|
||||
}
|
||||
if (store.lazy !== true && this.data) {
|
||||
this.setData(this.data);
|
||||
if (store.defaultExpandAll) {
|
||||
this.expanded = true;
|
||||
this.canFocus = true;
|
||||
}
|
||||
} else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) {
|
||||
this.expand();
|
||||
}
|
||||
if (!shared.isArray(this.data)) {
|
||||
util.markNodeData(this, this.data);
|
||||
}
|
||||
if (!this.data)
|
||||
return;
|
||||
const defaultExpandedKeys = store.defaultExpandedKeys;
|
||||
const key = store.key;
|
||||
if (key && !lodashUnified.isNil(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
|
||||
this.expand(null, store.autoExpandParent);
|
||||
}
|
||||
if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
|
||||
store.currentNode && (store.currentNode.isCurrent = false);
|
||||
store.currentNode = this;
|
||||
store.currentNode.isCurrent = true;
|
||||
}
|
||||
if (store.lazy) {
|
||||
store._initDefaultCheckedNode(this);
|
||||
}
|
||||
this.updateLeafState();
|
||||
if (this.level === 1 || ((_a = this.parent) == null ? void 0 : _a.expanded) === true)
|
||||
this.canFocus = true;
|
||||
}
|
||||
setData(data) {
|
||||
if (!shared.isArray(data)) {
|
||||
util.markNodeData(this, data);
|
||||
}
|
||||
this.data = data;
|
||||
this.childNodes = [];
|
||||
let children;
|
||||
if (this.level === 0 && shared.isArray(this.data)) {
|
||||
children = this.data;
|
||||
} else {
|
||||
children = getPropertyFromData(this, "children") || [];
|
||||
}
|
||||
for (let i = 0, j = children.length; i < j; i++) {
|
||||
this.insertChild({ data: children[i] });
|
||||
}
|
||||
}
|
||||
get label() {
|
||||
return getPropertyFromData(this, "label");
|
||||
}
|
||||
get key() {
|
||||
const nodeKey = this.store.key;
|
||||
if (this.data)
|
||||
return this.data[nodeKey];
|
||||
return null;
|
||||
}
|
||||
get disabled() {
|
||||
return getPropertyFromData(this, "disabled");
|
||||
}
|
||||
get nextSibling() {
|
||||
const parent = this.parent;
|
||||
if (parent) {
|
||||
const index = parent.childNodes.indexOf(this);
|
||||
if (index > -1) {
|
||||
return parent.childNodes[index + 1];
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
get previousSibling() {
|
||||
const parent = this.parent;
|
||||
if (parent) {
|
||||
const index = parent.childNodes.indexOf(this);
|
||||
if (index > -1) {
|
||||
return index > 0 ? parent.childNodes[index - 1] : null;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
contains(target, deep = true) {
|
||||
return (this.childNodes || []).some((child) => child === target || deep && child.contains(target));
|
||||
}
|
||||
remove() {
|
||||
const parent = this.parent;
|
||||
if (parent) {
|
||||
parent.removeChild(this);
|
||||
}
|
||||
}
|
||||
insertChild(child, index, batch) {
|
||||
if (!child)
|
||||
throw new Error("InsertChild error: child is required.");
|
||||
if (!(child instanceof Node)) {
|
||||
if (!batch) {
|
||||
const children = this.getChildren(true);
|
||||
if (!(children == null ? void 0 : children.includes(child.data))) {
|
||||
if (types.isUndefined(index) || index < 0) {
|
||||
children == null ? void 0 : children.push(child.data);
|
||||
} else {
|
||||
children == null ? void 0 : children.splice(index, 0, child.data);
|
||||
}
|
||||
}
|
||||
}
|
||||
Object.assign(child, {
|
||||
parent: this,
|
||||
store: this.store
|
||||
});
|
||||
child = vue.reactive(new Node(child));
|
||||
if (child instanceof Node) {
|
||||
child.initialize();
|
||||
}
|
||||
}
|
||||
child.level = this.level + 1;
|
||||
if (types.isUndefined(index) || index < 0) {
|
||||
this.childNodes.push(child);
|
||||
} else {
|
||||
this.childNodes.splice(index, 0, child);
|
||||
}
|
||||
this.updateLeafState();
|
||||
}
|
||||
insertBefore(child, ref) {
|
||||
let index;
|
||||
if (ref) {
|
||||
index = this.childNodes.indexOf(ref);
|
||||
}
|
||||
this.insertChild(child, index);
|
||||
}
|
||||
insertAfter(child, ref) {
|
||||
let index;
|
||||
if (ref) {
|
||||
index = this.childNodes.indexOf(ref);
|
||||
if (index !== -1)
|
||||
index += 1;
|
||||
}
|
||||
this.insertChild(child, index);
|
||||
}
|
||||
removeChild(child) {
|
||||
const children = this.getChildren() || [];
|
||||
const dataIndex = children.indexOf(child.data);
|
||||
if (dataIndex > -1) {
|
||||
children.splice(dataIndex, 1);
|
||||
}
|
||||
const index = this.childNodes.indexOf(child);
|
||||
if (index > -1) {
|
||||
this.store && this.store.deregisterNode(child);
|
||||
child.parent = null;
|
||||
this.childNodes.splice(index, 1);
|
||||
}
|
||||
this.updateLeafState();
|
||||
}
|
||||
removeChildByData(data) {
|
||||
const targetNode = this.childNodes.find((child) => child.data === data);
|
||||
if (targetNode) {
|
||||
this.removeChild(targetNode);
|
||||
}
|
||||
}
|
||||
expand(callback, expandParent) {
|
||||
const done = () => {
|
||||
if (expandParent) {
|
||||
let parent = this.parent;
|
||||
while (parent && parent.level > 0) {
|
||||
parent.expanded = true;
|
||||
parent = parent.parent;
|
||||
}
|
||||
}
|
||||
this.expanded = true;
|
||||
if (callback)
|
||||
callback();
|
||||
setCanFocus(this.childNodes, true);
|
||||
};
|
||||
if (this.shouldLoadData()) {
|
||||
this.loadData((data) => {
|
||||
if (shared.isArray(data)) {
|
||||
if (this.checked) {
|
||||
this.setChecked(true, true);
|
||||
} else if (!this.store.checkStrictly) {
|
||||
reInitChecked(this);
|
||||
}
|
||||
done();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
done();
|
||||
}
|
||||
}
|
||||
doCreateChildren(array, defaultProps = {}) {
|
||||
array.forEach((item) => {
|
||||
this.insertChild(Object.assign({ data: item }, defaultProps), void 0, true);
|
||||
});
|
||||
}
|
||||
collapse() {
|
||||
this.expanded = false;
|
||||
setCanFocus(this.childNodes, false);
|
||||
}
|
||||
shouldLoadData() {
|
||||
return Boolean(this.store.lazy === true && this.store.load && !this.loaded);
|
||||
}
|
||||
updateLeafState() {
|
||||
if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
|
||||
this.isLeaf = this.isLeafByUser;
|
||||
this.isEffectivelyChecked = this.isLeaf && this.disabled;
|
||||
return;
|
||||
}
|
||||
const childNodes = this.childNodes;
|
||||
if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
|
||||
this.isLeaf = !childNodes || childNodes.length === 0;
|
||||
this.isEffectivelyChecked = this.isLeaf && this.disabled;
|
||||
return;
|
||||
}
|
||||
this.isLeaf = false;
|
||||
}
|
||||
setChecked(value, deep, recursion, passValue) {
|
||||
this.indeterminate = value === "half";
|
||||
this.checked = value === true;
|
||||
this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked);
|
||||
if (this.store.checkStrictly)
|
||||
return;
|
||||
if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
|
||||
const handleDescendants = () => {
|
||||
if (deep) {
|
||||
const childNodes = this.childNodes;
|
||||
for (let i = 0, j = childNodes.length; i < j; i++) {
|
||||
const child = childNodes[i];
|
||||
passValue = passValue || value !== false;
|
||||
const isCheck = child.disabled && child.isLeaf ? child.checked : passValue;
|
||||
child.setChecked(isCheck, deep, true, passValue);
|
||||
}
|
||||
const { half, all, isEffectivelyChecked } = getChildState(childNodes);
|
||||
if (!all) {
|
||||
this.checked = all;
|
||||
this.indeterminate = half;
|
||||
}
|
||||
this.isEffectivelyChecked = !this.childNodes.length ? this.disabled || this.checked : isEffectivelyChecked;
|
||||
}
|
||||
};
|
||||
if (this.shouldLoadData()) {
|
||||
this.loadData(() => {
|
||||
handleDescendants();
|
||||
reInitChecked(this);
|
||||
}, {
|
||||
checked: value !== false
|
||||
});
|
||||
return;
|
||||
} else {
|
||||
handleDescendants();
|
||||
}
|
||||
}
|
||||
const parent = this.parent;
|
||||
if (!parent || parent.level === 0)
|
||||
return;
|
||||
if (!recursion) {
|
||||
reInitChecked(parent);
|
||||
}
|
||||
}
|
||||
getChildren(forceInit = false) {
|
||||
if (this.level === 0)
|
||||
return this.data;
|
||||
const data = this.data;
|
||||
if (!data)
|
||||
return null;
|
||||
const props = this.store.props;
|
||||
let children = "children";
|
||||
if (props) {
|
||||
children = props.children || "children";
|
||||
}
|
||||
if (types.isUndefined(data[children])) {
|
||||
data[children] = null;
|
||||
}
|
||||
if (forceInit && !data[children]) {
|
||||
data[children] = [];
|
||||
}
|
||||
return data[children];
|
||||
}
|
||||
updateChildren() {
|
||||
const newData = this.getChildren() || [];
|
||||
const oldData = this.childNodes.map((node) => node.data);
|
||||
const newDataMap = {};
|
||||
const newNodes = [];
|
||||
newData.forEach((item, index) => {
|
||||
const key = item[util.NODE_KEY];
|
||||
const isNodeExists = !!key && oldData.some((data) => (data == null ? void 0 : data[util.NODE_KEY]) === key);
|
||||
if (isNodeExists) {
|
||||
newDataMap[key] = { index, data: item };
|
||||
} else {
|
||||
newNodes.push({ index, data: item });
|
||||
}
|
||||
});
|
||||
if (!this.store.lazy) {
|
||||
oldData.forEach((item) => {
|
||||
if (!newDataMap[item == null ? void 0 : item[util.NODE_KEY]])
|
||||
this.removeChildByData(item);
|
||||
});
|
||||
}
|
||||
newNodes.forEach(({ index, data }) => {
|
||||
this.insertChild({ data }, index);
|
||||
});
|
||||
this.updateLeafState();
|
||||
}
|
||||
loadData(callback, defaultProps = {}) {
|
||||
if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
|
||||
this.loading = true;
|
||||
const resolve = (children) => {
|
||||
this.childNodes = [];
|
||||
this.doCreateChildren(children, defaultProps);
|
||||
this.loaded = true;
|
||||
this.loading = false;
|
||||
this.updateLeafState();
|
||||
if (callback) {
|
||||
callback.call(this, children);
|
||||
}
|
||||
};
|
||||
const reject = () => {
|
||||
this.loading = false;
|
||||
};
|
||||
this.store.load(this, resolve, reject);
|
||||
} else {
|
||||
if (callback) {
|
||||
callback.call(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
eachNode(callback) {
|
||||
const arr = [this];
|
||||
while (arr.length) {
|
||||
const node = arr.shift();
|
||||
arr.unshift(...node.childNodes);
|
||||
callback(node);
|
||||
}
|
||||
}
|
||||
reInitChecked() {
|
||||
if (this.store.checkStrictly)
|
||||
return;
|
||||
reInitChecked(this);
|
||||
}
|
||||
}
|
||||
|
||||
exports["default"] = Node;
|
||||
exports.getChildState = getChildState;
|
||||
//# sourceMappingURL=node.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+51
@@ -0,0 +1,51 @@
|
||||
import Node from './node';
|
||||
import type { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from '../tree.type';
|
||||
export default class TreeStore {
|
||||
currentNode: Node | null;
|
||||
currentNodeKey: TreeKey | null;
|
||||
nodesMap: TreeStoreNodesMap;
|
||||
root: Node;
|
||||
data: TreeData;
|
||||
lazy: boolean;
|
||||
load?: LoadFunction;
|
||||
filterNodeMethod?: FilterNodeMethodFunction;
|
||||
key: TreeKey;
|
||||
defaultCheckedKeys?: TreeKey[];
|
||||
checkStrictly: boolean;
|
||||
defaultExpandedKeys?: TreeKey[];
|
||||
autoExpandParent: boolean;
|
||||
defaultExpandAll: boolean;
|
||||
checkDescendants: boolean;
|
||||
props: TreeOptionProps;
|
||||
constructor(options: TreeStoreOptions);
|
||||
initialize(): void;
|
||||
filter(value: FilterValue): void;
|
||||
setData(newVal: TreeData): void;
|
||||
getNode(data: TreeKey | TreeNodeData | Node): Node;
|
||||
insertBefore(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
|
||||
insertAfter(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
|
||||
remove(data: TreeNodeData | Node): void;
|
||||
append(data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node): void;
|
||||
_initDefaultCheckedNodes(): void;
|
||||
_initDefaultCheckedNode(node: Node): void;
|
||||
setDefaultCheckedKey(newVal: TreeKey[]): void;
|
||||
registerNode(node: Node): void;
|
||||
deregisterNode(node: Node): void;
|
||||
getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNodeData[];
|
||||
getCheckedKeys(leafOnly?: boolean): TreeKey[];
|
||||
getHalfCheckedNodes(): TreeNodeData[];
|
||||
getHalfCheckedKeys(): TreeKey[];
|
||||
_getAllNodes(): Node[];
|
||||
updateChildren(key: TreeKey, data: TreeData): void;
|
||||
_setCheckedKeys(key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
|
||||
[key: string]: boolean;
|
||||
}): void;
|
||||
setCheckedNodes(array: Node[], leafOnly?: boolean): void;
|
||||
setCheckedKeys(keys: TreeKey[], leafOnly?: boolean): void;
|
||||
setDefaultExpandedKeys(keys: TreeKey[]): void;
|
||||
setChecked(data: TreeKey | TreeNodeData, checked: boolean, deep: boolean): void;
|
||||
getCurrentNode(): Node | null;
|
||||
setCurrentNode(currentNode: Node): void;
|
||||
setUserCurrentNode(node: Node, shouldAutoExpandParent?: boolean): void;
|
||||
setCurrentNodeKey(key: TreeKey | null, shouldAutoExpandParent?: boolean): void;
|
||||
}
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var vue = require('vue');
|
||||
var lodashUnified = require('lodash-unified');
|
||||
var node = require('./node.js');
|
||||
var util = require('./util.js');
|
||||
var shared = require('@vue/shared');
|
||||
var types = require('../../../../utils/types.js');
|
||||
|
||||
class TreeStore {
|
||||
constructor(options) {
|
||||
this.lazy = false;
|
||||
this.checkStrictly = false;
|
||||
this.autoExpandParent = false;
|
||||
this.defaultExpandAll = false;
|
||||
this.checkDescendants = false;
|
||||
this.currentNode = null;
|
||||
this.currentNodeKey = null;
|
||||
for (const option in options) {
|
||||
if (shared.hasOwn(options, option)) {
|
||||
this[option] = options[option];
|
||||
}
|
||||
}
|
||||
this.nodesMap = {};
|
||||
}
|
||||
initialize() {
|
||||
this.root = new node["default"]({
|
||||
data: this.data,
|
||||
store: this
|
||||
});
|
||||
this.root.initialize();
|
||||
if (this.lazy && this.load) {
|
||||
const loadFn = this.load;
|
||||
loadFn(this.root, (data) => {
|
||||
this.root.doCreateChildren(data);
|
||||
this._initDefaultCheckedNodes();
|
||||
}, shared.NOOP);
|
||||
} else {
|
||||
this._initDefaultCheckedNodes();
|
||||
}
|
||||
}
|
||||
filter(value) {
|
||||
const filterNodeMethod = this.filterNodeMethod;
|
||||
const lazy = this.lazy;
|
||||
const traverse = async function(node) {
|
||||
const childNodes = node.root ? node.root.childNodes : node.childNodes;
|
||||
for (const [index, child] of childNodes.entries()) {
|
||||
child.visible = !!(filterNodeMethod == null ? void 0 : filterNodeMethod.call(child, value, child.data, child));
|
||||
if (index % 80 === 0 && index > 0) {
|
||||
await vue.nextTick();
|
||||
}
|
||||
await traverse(child);
|
||||
}
|
||||
if (!node.visible && childNodes.length) {
|
||||
let allHidden = true;
|
||||
allHidden = !childNodes.some((child) => child.visible);
|
||||
if (node.root) {
|
||||
node.root.visible = allHidden === false;
|
||||
} else {
|
||||
node.visible = allHidden === false;
|
||||
}
|
||||
}
|
||||
if (!value)
|
||||
return;
|
||||
if (node.visible && !node.isLeaf) {
|
||||
if (!lazy || node.loaded) {
|
||||
node.expand();
|
||||
}
|
||||
}
|
||||
};
|
||||
traverse(this);
|
||||
}
|
||||
setData(newVal) {
|
||||
const instanceChanged = newVal !== this.root.data;
|
||||
if (instanceChanged) {
|
||||
this.nodesMap = {};
|
||||
this.root.setData(newVal);
|
||||
this._initDefaultCheckedNodes();
|
||||
this.setCurrentNodeKey(this.currentNodeKey);
|
||||
} else {
|
||||
this.root.updateChildren();
|
||||
}
|
||||
}
|
||||
getNode(data) {
|
||||
if (data instanceof node["default"])
|
||||
return data;
|
||||
const key = shared.isObject(data) ? util.getNodeKey(this.key, data) : data;
|
||||
return this.nodesMap[key] || null;
|
||||
}
|
||||
insertBefore(data, refData) {
|
||||
var _a;
|
||||
const refNode = this.getNode(refData);
|
||||
(_a = refNode.parent) == null ? void 0 : _a.insertBefore({ data }, refNode);
|
||||
}
|
||||
insertAfter(data, refData) {
|
||||
var _a;
|
||||
const refNode = this.getNode(refData);
|
||||
(_a = refNode.parent) == null ? void 0 : _a.insertAfter({ data }, refNode);
|
||||
}
|
||||
remove(data) {
|
||||
const node = this.getNode(data);
|
||||
if (node && node.parent) {
|
||||
if (node === this.currentNode) {
|
||||
this.currentNode = null;
|
||||
}
|
||||
node.parent.removeChild(node);
|
||||
}
|
||||
}
|
||||
append(data, parentData) {
|
||||
const parentNode = !types.isPropAbsent(parentData) ? this.getNode(parentData) : this.root;
|
||||
if (parentNode) {
|
||||
parentNode.insertChild({ data });
|
||||
}
|
||||
}
|
||||
_initDefaultCheckedNodes() {
|
||||
const defaultCheckedKeys = this.defaultCheckedKeys || [];
|
||||
const nodesMap = this.nodesMap;
|
||||
defaultCheckedKeys.forEach((checkedKey) => {
|
||||
const node = nodesMap[checkedKey];
|
||||
if (node) {
|
||||
node.setChecked(true, !this.checkStrictly);
|
||||
}
|
||||
});
|
||||
}
|
||||
_initDefaultCheckedNode(node) {
|
||||
const defaultCheckedKeys = this.defaultCheckedKeys || [];
|
||||
if (!lodashUnified.isNil(node.key) && defaultCheckedKeys.includes(node.key)) {
|
||||
node.setChecked(true, !this.checkStrictly);
|
||||
}
|
||||
}
|
||||
setDefaultCheckedKey(newVal) {
|
||||
if (newVal !== this.defaultCheckedKeys) {
|
||||
this.defaultCheckedKeys = newVal;
|
||||
this._initDefaultCheckedNodes();
|
||||
}
|
||||
}
|
||||
registerNode(node) {
|
||||
const key = this.key;
|
||||
if (!node || !node.data)
|
||||
return;
|
||||
if (!key) {
|
||||
this.nodesMap[node.id] = node;
|
||||
} else {
|
||||
const nodeKey = node.key;
|
||||
if (!lodashUnified.isNil(nodeKey))
|
||||
this.nodesMap[nodeKey] = node;
|
||||
}
|
||||
}
|
||||
deregisterNode(node) {
|
||||
const key = this.key;
|
||||
if (!key || !node || !node.data)
|
||||
return;
|
||||
node.childNodes.forEach((child) => {
|
||||
this.deregisterNode(child);
|
||||
});
|
||||
delete this.nodesMap[node.key];
|
||||
}
|
||||
getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
|
||||
const checkedNodes = [];
|
||||
const traverse = function(node) {
|
||||
const childNodes = node.root ? node.root.childNodes : node.childNodes;
|
||||
childNodes.forEach((child) => {
|
||||
if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
|
||||
checkedNodes.push(child.data);
|
||||
}
|
||||
traverse(child);
|
||||
});
|
||||
};
|
||||
traverse(this);
|
||||
return checkedNodes;
|
||||
}
|
||||
getCheckedKeys(leafOnly = false) {
|
||||
return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
|
||||
}
|
||||
getHalfCheckedNodes() {
|
||||
const nodes = [];
|
||||
const traverse = function(node) {
|
||||
const childNodes = node.root ? node.root.childNodes : node.childNodes;
|
||||
childNodes.forEach((child) => {
|
||||
if (child.indeterminate) {
|
||||
nodes.push(child.data);
|
||||
}
|
||||
traverse(child);
|
||||
});
|
||||
};
|
||||
traverse(this);
|
||||
return nodes;
|
||||
}
|
||||
getHalfCheckedKeys() {
|
||||
return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
|
||||
}
|
||||
_getAllNodes() {
|
||||
const allNodes = [];
|
||||
const nodesMap = this.nodesMap;
|
||||
for (const nodeKey in nodesMap) {
|
||||
if (shared.hasOwn(nodesMap, nodeKey)) {
|
||||
allNodes.push(nodesMap[nodeKey]);
|
||||
}
|
||||
}
|
||||
return allNodes;
|
||||
}
|
||||
updateChildren(key, data) {
|
||||
const node = this.nodesMap[key];
|
||||
if (!node)
|
||||
return;
|
||||
const childNodes = node.childNodes;
|
||||
for (let i = childNodes.length - 1; i >= 0; i--) {
|
||||
const child = childNodes[i];
|
||||
this.remove(child.data);
|
||||
}
|
||||
for (let i = 0, j = data.length; i < j; i++) {
|
||||
const child = data[i];
|
||||
this.append(child, node.data);
|
||||
}
|
||||
}
|
||||
_setCheckedKeys(key, leafOnly = false, checkedKeys) {
|
||||
const allNodes = this._getAllNodes().sort((a, b) => a.level - b.level);
|
||||
const cache = /* @__PURE__ */ Object.create(null);
|
||||
const keys = Object.keys(checkedKeys);
|
||||
allNodes.forEach((node) => node.setChecked(false, false));
|
||||
const cacheCheckedChild = (node) => {
|
||||
node.childNodes.forEach((child) => {
|
||||
var _a;
|
||||
cache[child.data[key]] = true;
|
||||
if ((_a = child.childNodes) == null ? void 0 : _a.length) {
|
||||
cacheCheckedChild(child);
|
||||
}
|
||||
});
|
||||
};
|
||||
for (let i = 0, j = allNodes.length; i < j; i++) {
|
||||
const node = allNodes[i];
|
||||
const nodeKey = node.data[key].toString();
|
||||
const checked = keys.includes(nodeKey);
|
||||
if (!checked) {
|
||||
if (node.checked && !cache[nodeKey]) {
|
||||
node.setChecked(false, false);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (node.childNodes.length) {
|
||||
cacheCheckedChild(node);
|
||||
}
|
||||
if (node.isLeaf || this.checkStrictly) {
|
||||
node.setChecked(true, false);
|
||||
continue;
|
||||
}
|
||||
node.setChecked(true, true);
|
||||
if (leafOnly) {
|
||||
node.setChecked(false, false);
|
||||
const traverse = function(node2) {
|
||||
const childNodes = node2.childNodes;
|
||||
childNodes.forEach((child) => {
|
||||
if (!child.isLeaf) {
|
||||
child.setChecked(false, false);
|
||||
}
|
||||
traverse(child);
|
||||
});
|
||||
};
|
||||
traverse(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
setCheckedNodes(array, leafOnly = false) {
|
||||
const key = this.key;
|
||||
const checkedKeys = {};
|
||||
array.forEach((item) => {
|
||||
checkedKeys[(item || {})[key]] = true;
|
||||
});
|
||||
this._setCheckedKeys(key, leafOnly, checkedKeys);
|
||||
}
|
||||
setCheckedKeys(keys, leafOnly = false) {
|
||||
this.defaultCheckedKeys = keys;
|
||||
const key = this.key;
|
||||
const checkedKeys = {};
|
||||
keys.forEach((key2) => {
|
||||
checkedKeys[key2] = true;
|
||||
});
|
||||
this._setCheckedKeys(key, leafOnly, checkedKeys);
|
||||
}
|
||||
setDefaultExpandedKeys(keys) {
|
||||
keys = keys || [];
|
||||
this.defaultExpandedKeys = keys;
|
||||
keys.forEach((key) => {
|
||||
const node = this.getNode(key);
|
||||
if (node)
|
||||
node.expand(null, this.autoExpandParent);
|
||||
});
|
||||
}
|
||||
setChecked(data, checked, deep) {
|
||||
const node = this.getNode(data);
|
||||
if (node) {
|
||||
node.setChecked(!!checked, deep);
|
||||
}
|
||||
}
|
||||
getCurrentNode() {
|
||||
return this.currentNode;
|
||||
}
|
||||
setCurrentNode(currentNode) {
|
||||
const prevCurrentNode = this.currentNode;
|
||||
if (prevCurrentNode) {
|
||||
prevCurrentNode.isCurrent = false;
|
||||
}
|
||||
this.currentNode = currentNode;
|
||||
this.currentNode.isCurrent = true;
|
||||
}
|
||||
setUserCurrentNode(node, shouldAutoExpandParent = true) {
|
||||
var _a;
|
||||
const key = node[this.key];
|
||||
const currNode = this.nodesMap[key];
|
||||
this.setCurrentNode(currNode);
|
||||
if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) {
|
||||
(_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
|
||||
}
|
||||
}
|
||||
setCurrentNodeKey(key, shouldAutoExpandParent = true) {
|
||||
var _a;
|
||||
this.currentNodeKey = key;
|
||||
if (types.isPropAbsent(key)) {
|
||||
this.currentNode && (this.currentNode.isCurrent = false);
|
||||
this.currentNode = null;
|
||||
return;
|
||||
}
|
||||
const node = this.getNode(key);
|
||||
if (node) {
|
||||
this.setCurrentNode(node);
|
||||
if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) {
|
||||
(_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
exports["default"] = TreeStore;
|
||||
//# sourceMappingURL=tree-store.js.map
|
||||
Generated
Vendored
+1
File diff suppressed because one or more lines are too long
Generated
Vendored
+243
@@ -0,0 +1,243 @@
|
||||
import type { InjectionKey, Ref, SetupContext } from 'vue';
|
||||
import type { AllowDragFunction, AllowDropFunction, FakeNode, NodeDropType } from '../tree.type';
|
||||
import type TreeStore from './tree-store';
|
||||
import type Node from './node';
|
||||
import type { treeEmits } from '../tree';
|
||||
interface TreeNode {
|
||||
node: Node;
|
||||
$el?: HTMLElement;
|
||||
}
|
||||
interface DragOptions {
|
||||
event: DragEvent;
|
||||
treeNode: TreeNode;
|
||||
}
|
||||
interface Props {
|
||||
props: {
|
||||
allowDrag?: AllowDragFunction;
|
||||
allowDrop?: AllowDropFunction;
|
||||
};
|
||||
ctx: SetupContext<typeof treeEmits>;
|
||||
el$: Ref<HTMLElement | null>;
|
||||
dropIndicator$: Ref<HTMLElement | null>;
|
||||
store: Ref<TreeStore>;
|
||||
}
|
||||
export interface DragEvents {
|
||||
treeNodeDragStart: (options: DragOptions) => void;
|
||||
treeNodeDragOver: (options: DragOptions) => void;
|
||||
treeNodeDragEnd: (event: DragEvent) => void;
|
||||
}
|
||||
export declare const dragEventsKey: InjectionKey<DragEvents>;
|
||||
export declare function useDragNodeHandler({ props, ctx, el$, dropIndicator$, store, }: Props): {
|
||||
dragState: Ref<{
|
||||
allowDrop: boolean;
|
||||
dropType: NodeDropType | null;
|
||||
draggingNode: {
|
||||
node: {
|
||||
id: number;
|
||||
text: string | null;
|
||||
checked: boolean;
|
||||
indeterminate: boolean;
|
||||
data: import("../tree.type").TreeNodeData;
|
||||
expanded: boolean;
|
||||
parent: any | null;
|
||||
visible: boolean;
|
||||
isCurrent: boolean;
|
||||
store: {
|
||||
currentNode: any | null;
|
||||
currentNodeKey: import("../tree.type").TreeKey | null;
|
||||
nodesMap: import("../tree.type").TreeStoreNodesMap;
|
||||
root: any;
|
||||
data: import("../tree.type").TreeNodeData[];
|
||||
lazy: boolean;
|
||||
load?: import("../tree.type").LoadFunction | undefined;
|
||||
filterNodeMethod?: import("../tree.type").FilterNodeMethodFunction | undefined;
|
||||
key: import("../tree.type").TreeKey;
|
||||
defaultCheckedKeys?: import("../tree.type").TreeKey[] | undefined;
|
||||
checkStrictly: boolean;
|
||||
defaultExpandedKeys?: import("../tree.type").TreeKey[] | undefined;
|
||||
autoExpandParent: boolean;
|
||||
defaultExpandAll: boolean;
|
||||
checkDescendants: boolean;
|
||||
props: {
|
||||
children?: string | undefined;
|
||||
label?: (string | ((data: import("../tree.type").TreeNodeData, node: Node) => string)) | undefined;
|
||||
disabled?: (string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean)) | undefined;
|
||||
isLeaf?: (string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean)) | undefined;
|
||||
class?: ((data: import("../tree.type").TreeNodeData, node: Node) => string | {
|
||||
[key: string]: boolean;
|
||||
}) | undefined;
|
||||
};
|
||||
initialize: () => void;
|
||||
filter: (value: import("../tree.type").FilterValue) => void;
|
||||
setData: (newVal: import("../tree.type").TreeData) => void;
|
||||
getNode: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => Node;
|
||||
insertBefore: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
|
||||
insertAfter: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
|
||||
remove: (data: import("../tree.type").TreeNodeData | Node) => void;
|
||||
append: (data: import("../tree.type").TreeNodeData, parentData: import("../tree.type").TreeNodeData | import("../tree.type").TreeKey | Node) => void;
|
||||
_initDefaultCheckedNodes: () => void;
|
||||
_initDefaultCheckedNode: (node: Node) => void;
|
||||
setDefaultCheckedKey: (newVal: import("../tree.type").TreeKey[]) => void;
|
||||
registerNode: (node: Node) => void;
|
||||
deregisterNode: (node: Node) => void;
|
||||
getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("../tree.type").TreeNodeData[];
|
||||
getCheckedKeys: (leafOnly?: boolean) => import("../tree.type").TreeKey[];
|
||||
getHalfCheckedNodes: () => import("../tree.type").TreeNodeData[];
|
||||
getHalfCheckedKeys: () => import("../tree.type").TreeKey[];
|
||||
_getAllNodes: () => Node[];
|
||||
updateChildren: (key: import("../tree.type").TreeKey, data: import("../tree.type").TreeData) => void;
|
||||
_setCheckedKeys: (key: import("../tree.type").TreeKey, leafOnly: boolean | undefined, checkedKeys: {
|
||||
[key: string]: boolean;
|
||||
}) => void;
|
||||
setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
|
||||
setCheckedKeys: (keys: import("../tree.type").TreeKey[], leafOnly?: boolean) => void;
|
||||
setDefaultExpandedKeys: (keys: import("../tree.type").TreeKey[]) => void;
|
||||
setChecked: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData, checked: boolean, deep: boolean) => void;
|
||||
getCurrentNode: () => Node | null;
|
||||
setCurrentNode: (currentNode: Node) => void;
|
||||
setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
|
||||
setCurrentNodeKey: (key: import("../tree.type").TreeKey | null, shouldAutoExpandParent?: boolean) => void;
|
||||
};
|
||||
isLeafByUser: boolean | undefined;
|
||||
isLeaf: boolean | undefined;
|
||||
canFocus: boolean;
|
||||
level: number;
|
||||
loaded: boolean;
|
||||
childNodes: any[];
|
||||
loading: boolean;
|
||||
isEffectivelyChecked: boolean;
|
||||
initialize: () => void;
|
||||
setData: (data: import("../tree.type").TreeNodeData) => void;
|
||||
readonly label: string;
|
||||
readonly key: import("../tree.type").TreeKey | null | undefined;
|
||||
readonly disabled: boolean;
|
||||
readonly nextSibling: any | null;
|
||||
readonly previousSibling: any | null;
|
||||
contains: (target: Node, deep?: boolean) => boolean;
|
||||
remove: () => void;
|
||||
insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
|
||||
insertBefore: (child: FakeNode | Node, ref: Node) => void;
|
||||
insertAfter: (child: FakeNode | Node, ref: Node) => void;
|
||||
removeChild: (child: Node) => void;
|
||||
removeChildByData: (data: import("../tree.type").TreeNodeData | null) => void;
|
||||
expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
|
||||
doCreateChildren: (array: import("../tree.type").TreeNodeData[], defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
|
||||
collapse: () => void;
|
||||
shouldLoadData: () => boolean;
|
||||
updateLeafState: () => void;
|
||||
setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
|
||||
getChildren: (forceInit?: boolean) => import("../tree.type").TreeNodeData | import("../tree.type").TreeNodeData[] | null;
|
||||
updateChildren: () => void;
|
||||
loadData: (callback: (data?: import("../tree.type").TreeNodeData[]) => void, defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
|
||||
eachNode: (callback: (node: Node) => void) => void;
|
||||
reInitChecked: () => void;
|
||||
};
|
||||
$el?: HTMLElement | undefined;
|
||||
} | null;
|
||||
showDropIndicator: boolean;
|
||||
dropNode: {
|
||||
node: {
|
||||
id: number;
|
||||
text: string | null;
|
||||
checked: boolean;
|
||||
indeterminate: boolean;
|
||||
data: import("../tree.type").TreeNodeData;
|
||||
expanded: boolean;
|
||||
parent: any | null;
|
||||
visible: boolean;
|
||||
isCurrent: boolean;
|
||||
store: {
|
||||
currentNode: any | null;
|
||||
currentNodeKey: import("../tree.type").TreeKey | null;
|
||||
nodesMap: import("../tree.type").TreeStoreNodesMap;
|
||||
root: any;
|
||||
data: import("../tree.type").TreeNodeData[];
|
||||
lazy: boolean;
|
||||
load?: import("../tree.type").LoadFunction | undefined;
|
||||
filterNodeMethod?: import("../tree.type").FilterNodeMethodFunction | undefined;
|
||||
key: import("../tree.type").TreeKey;
|
||||
defaultCheckedKeys?: import("../tree.type").TreeKey[] | undefined;
|
||||
checkStrictly: boolean;
|
||||
defaultExpandedKeys?: import("../tree.type").TreeKey[] | undefined;
|
||||
autoExpandParent: boolean;
|
||||
defaultExpandAll: boolean;
|
||||
checkDescendants: boolean;
|
||||
props: {
|
||||
children?: string | undefined;
|
||||
label?: (string | ((data: import("../tree.type").TreeNodeData, node: Node) => string)) | undefined;
|
||||
disabled?: (string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean)) | undefined;
|
||||
isLeaf?: (string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean)) | undefined;
|
||||
class?: ((data: import("../tree.type").TreeNodeData, node: Node) => string | {
|
||||
[key: string]: boolean;
|
||||
}) | undefined;
|
||||
};
|
||||
initialize: () => void;
|
||||
filter: (value: import("../tree.type").FilterValue) => void;
|
||||
setData: (newVal: import("../tree.type").TreeData) => void;
|
||||
getNode: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => Node;
|
||||
insertBefore: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
|
||||
insertAfter: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
|
||||
remove: (data: import("../tree.type").TreeNodeData | Node) => void;
|
||||
append: (data: import("../tree.type").TreeNodeData, parentData: import("../tree.type").TreeNodeData | import("../tree.type").TreeKey | Node) => void;
|
||||
_initDefaultCheckedNodes: () => void;
|
||||
_initDefaultCheckedNode: (node: Node) => void;
|
||||
setDefaultCheckedKey: (newVal: import("../tree.type").TreeKey[]) => void;
|
||||
registerNode: (node: Node) => void;
|
||||
deregisterNode: (node: Node) => void;
|
||||
getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("../tree.type").TreeNodeData[];
|
||||
getCheckedKeys: (leafOnly?: boolean) => import("../tree.type").TreeKey[];
|
||||
getHalfCheckedNodes: () => import("../tree.type").TreeNodeData[];
|
||||
getHalfCheckedKeys: () => import("../tree.type").TreeKey[];
|
||||
_getAllNodes: () => Node[];
|
||||
updateChildren: (key: import("../tree.type").TreeKey, data: import("../tree.type").TreeData) => void;
|
||||
_setCheckedKeys: (key: import("../tree.type").TreeKey, leafOnly: boolean | undefined, checkedKeys: {
|
||||
[key: string]: boolean;
|
||||
}) => void;
|
||||
setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
|
||||
setCheckedKeys: (keys: import("../tree.type").TreeKey[], leafOnly?: boolean) => void;
|
||||
setDefaultExpandedKeys: (keys: import("../tree.type").TreeKey[]) => void;
|
||||
setChecked: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData, checked: boolean, deep: boolean) => void;
|
||||
getCurrentNode: () => Node | null;
|
||||
setCurrentNode: (currentNode: Node) => void;
|
||||
setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
|
||||
setCurrentNodeKey: (key: import("../tree.type").TreeKey | null, shouldAutoExpandParent?: boolean) => void;
|
||||
};
|
||||
isLeafByUser: boolean | undefined;
|
||||
isLeaf: boolean | undefined;
|
||||
canFocus: boolean;
|
||||
level: number;
|
||||
loaded: boolean;
|
||||
childNodes: any[];
|
||||
loading: boolean;
|
||||
isEffectivelyChecked: boolean;
|
||||
initialize: () => void;
|
||||
setData: (data: import("../tree.type").TreeNodeData) => void;
|
||||
readonly label: string;
|
||||
readonly key: import("../tree.type").TreeKey | null | undefined;
|
||||
readonly disabled: boolean;
|
||||
readonly nextSibling: any | null;
|
||||
readonly previousSibling: any | null;
|
||||
contains: (target: Node, deep?: boolean) => boolean;
|
||||
remove: () => void;
|
||||
insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
|
||||
insertBefore: (child: FakeNode | Node, ref: Node) => void;
|
||||
insertAfter: (child: FakeNode | Node, ref: Node) => void;
|
||||
removeChild: (child: Node) => void;
|
||||
removeChildByData: (data: import("../tree.type").TreeNodeData | null) => void;
|
||||
expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
|
||||
doCreateChildren: (array: import("../tree.type").TreeNodeData[], defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
|
||||
collapse: () => void;
|
||||
shouldLoadData: () => boolean;
|
||||
updateLeafState: () => void;
|
||||
setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
|
||||
getChildren: (forceInit?: boolean) => import("../tree.type").TreeNodeData | import("../tree.type").TreeNodeData[] | null;
|
||||
updateChildren: () => void;
|
||||
loadData: (callback: (data?: import("../tree.type").TreeNodeData[]) => void, defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
|
||||
eachNode: (callback: (node: Node) => void) => void;
|
||||
reInitChecked: () => void;
|
||||
};
|
||||
$el?: HTMLElement | undefined;
|
||||
} | null;
|
||||
}>;
|
||||
};
|
||||
export {};
|
||||
+178
@@ -0,0 +1,178 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var vue = require('vue');
|
||||
var index = require('../../../../hooks/use-namespace/index.js');
|
||||
var shared = require('@vue/shared');
|
||||
var style = require('../../../../utils/dom/style.js');
|
||||
|
||||
const dragEventsKey = Symbol("dragEvents");
|
||||
function useDragNodeHandler({
|
||||
props,
|
||||
ctx,
|
||||
el$,
|
||||
dropIndicator$,
|
||||
store
|
||||
}) {
|
||||
const ns = index.useNamespace("tree");
|
||||
const dragState = vue.ref({
|
||||
showDropIndicator: false,
|
||||
draggingNode: null,
|
||||
dropNode: null,
|
||||
allowDrop: true,
|
||||
dropType: null
|
||||
});
|
||||
const treeNodeDragStart = ({ event, treeNode }) => {
|
||||
if (!event.dataTransfer)
|
||||
return;
|
||||
if (shared.isFunction(props.allowDrag) && !props.allowDrag(treeNode.node)) {
|
||||
event.preventDefault();
|
||||
return false;
|
||||
}
|
||||
event.dataTransfer.effectAllowed = "move";
|
||||
try {
|
||||
event.dataTransfer.setData("text/plain", "");
|
||||
} catch (e) {
|
||||
}
|
||||
dragState.value.draggingNode = treeNode;
|
||||
ctx.emit("node-drag-start", treeNode.node, event);
|
||||
};
|
||||
const treeNodeDragOver = ({ event, treeNode }) => {
|
||||
if (!event.dataTransfer)
|
||||
return;
|
||||
const dropNode = treeNode;
|
||||
const oldDropNode = dragState.value.dropNode;
|
||||
if (oldDropNode && oldDropNode.node.id !== dropNode.node.id) {
|
||||
style.removeClass(oldDropNode.$el, ns.is("drop-inner"));
|
||||
}
|
||||
const draggingNode = dragState.value.draggingNode;
|
||||
if (!draggingNode || !dropNode)
|
||||
return;
|
||||
let dropPrev = true;
|
||||
let dropInner = true;
|
||||
let dropNext = true;
|
||||
let userAllowDropInner = true;
|
||||
if (shared.isFunction(props.allowDrop)) {
|
||||
dropPrev = props.allowDrop(draggingNode.node, dropNode.node, "prev");
|
||||
userAllowDropInner = dropInner = props.allowDrop(draggingNode.node, dropNode.node, "inner");
|
||||
dropNext = props.allowDrop(draggingNode.node, dropNode.node, "next");
|
||||
}
|
||||
event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
|
||||
if ((dropPrev || dropInner || dropNext) && (oldDropNode == null ? void 0 : oldDropNode.node.id) !== dropNode.node.id) {
|
||||
if (oldDropNode) {
|
||||
ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
|
||||
}
|
||||
ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
|
||||
}
|
||||
if (dropPrev || dropInner || dropNext) {
|
||||
dragState.value.dropNode = dropNode;
|
||||
} else {
|
||||
dragState.value.dropNode = null;
|
||||
}
|
||||
if (dropNode.node.nextSibling === draggingNode.node) {
|
||||
dropNext = false;
|
||||
}
|
||||
if (dropNode.node.previousSibling === draggingNode.node) {
|
||||
dropPrev = false;
|
||||
}
|
||||
if (dropNode.node.contains(draggingNode.node, false)) {
|
||||
dropInner = false;
|
||||
}
|
||||
if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
|
||||
dropPrev = false;
|
||||
dropInner = false;
|
||||
dropNext = false;
|
||||
}
|
||||
const dropEl = dropNode.$el;
|
||||
const targetPosition = dropEl.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
|
||||
const treePosition = el$.value.getBoundingClientRect();
|
||||
const treeScrollTop = el$.value.scrollTop;
|
||||
let dropType;
|
||||
const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : Number.NEGATIVE_INFINITY;
|
||||
const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : Number.POSITIVE_INFINITY;
|
||||
let indicatorTop = -9999;
|
||||
const distance = event.clientY - targetPosition.top;
|
||||
if (distance < targetPosition.height * prevPercent) {
|
||||
dropType = "before";
|
||||
} else if (distance > targetPosition.height * nextPercent) {
|
||||
dropType = "after";
|
||||
} else if (dropInner) {
|
||||
dropType = "inner";
|
||||
} else {
|
||||
dropType = "none";
|
||||
}
|
||||
const iconPosition = dropEl.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
|
||||
const dropIndicator = dropIndicator$.value;
|
||||
if (dropType === "before") {
|
||||
indicatorTop = iconPosition.top - treePosition.top + treeScrollTop;
|
||||
} else if (dropType === "after") {
|
||||
indicatorTop = iconPosition.bottom - treePosition.top + treeScrollTop;
|
||||
}
|
||||
dropIndicator.style.top = `${indicatorTop}px`;
|
||||
dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
|
||||
if (dropType === "inner") {
|
||||
style.addClass(dropEl, ns.is("drop-inner"));
|
||||
} else {
|
||||
style.removeClass(dropEl, ns.is("drop-inner"));
|
||||
}
|
||||
dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
|
||||
dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
|
||||
dragState.value.dropType = dropType;
|
||||
ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
|
||||
};
|
||||
const treeNodeDragEnd = (event) => {
|
||||
var _a, _b;
|
||||
const { draggingNode, dropType, dropNode } = dragState.value;
|
||||
event.preventDefault();
|
||||
if (event.dataTransfer) {
|
||||
event.dataTransfer.dropEffect = "move";
|
||||
}
|
||||
if ((draggingNode == null ? void 0 : draggingNode.node.data) && dropNode) {
|
||||
const draggingNodeCopy = { data: draggingNode.node.data };
|
||||
if (dropType !== "none") {
|
||||
draggingNode.node.remove();
|
||||
}
|
||||
if (dropType === "before") {
|
||||
(_a = dropNode.node.parent) == null ? void 0 : _a.insertBefore(draggingNodeCopy, dropNode.node);
|
||||
} else if (dropType === "after") {
|
||||
(_b = dropNode.node.parent) == null ? void 0 : _b.insertAfter(draggingNodeCopy, dropNode.node);
|
||||
} else if (dropType === "inner") {
|
||||
dropNode.node.insertChild(draggingNodeCopy);
|
||||
}
|
||||
if (dropType !== "none") {
|
||||
store.value.registerNode(draggingNodeCopy);
|
||||
if (store.value.key) {
|
||||
draggingNode.node.eachNode((node) => {
|
||||
var _a2;
|
||||
(_a2 = store.value.nodesMap[node.data[store.value.key]]) == null ? void 0 : _a2.setChecked(node.checked, !store.value.checkStrictly);
|
||||
});
|
||||
}
|
||||
}
|
||||
style.removeClass(dropNode.$el, ns.is("drop-inner"));
|
||||
ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
|
||||
if (dropType !== "none") {
|
||||
ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
|
||||
}
|
||||
}
|
||||
if (draggingNode && !dropNode) {
|
||||
ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
|
||||
}
|
||||
dragState.value.showDropIndicator = false;
|
||||
dragState.value.draggingNode = null;
|
||||
dragState.value.dropNode = null;
|
||||
dragState.value.allowDrop = true;
|
||||
};
|
||||
vue.provide(dragEventsKey, {
|
||||
treeNodeDragStart,
|
||||
treeNodeDragOver,
|
||||
treeNodeDragEnd
|
||||
});
|
||||
return {
|
||||
dragState
|
||||
};
|
||||
}
|
||||
|
||||
exports.dragEventsKey = dragEventsKey;
|
||||
exports.useDragNodeHandler = useDragNodeHandler;
|
||||
//# sourceMappingURL=useDragNode.js.map
|
||||
Generated
Vendored
+1
File diff suppressed because one or more lines are too long
+7
@@ -0,0 +1,7 @@
|
||||
import type TreeStore from './tree-store';
|
||||
import type { Ref } from 'vue';
|
||||
interface UseKeydownOption {
|
||||
el$: Ref<HTMLElement | null>;
|
||||
}
|
||||
export declare function useKeydown({ el$ }: UseKeydownOption, store: Ref<TreeStore>): void;
|
||||
export {};
|
||||
+102
@@ -0,0 +1,102 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var vue = require('vue');
|
||||
var core = require('@vueuse/core');
|
||||
var index = require('../../../../hooks/use-namespace/index.js');
|
||||
var event = require('../../../../utils/dom/event.js');
|
||||
var aria = require('../../../../constants/aria.js');
|
||||
|
||||
function useKeydown({ el$ }, store) {
|
||||
const ns = index.useNamespace("tree");
|
||||
vue.onMounted(() => {
|
||||
initTabIndex();
|
||||
});
|
||||
vue.onUpdated(() => {
|
||||
const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
|
||||
checkboxItems.forEach((checkbox) => {
|
||||
checkbox.setAttribute("tabindex", "-1");
|
||||
});
|
||||
});
|
||||
function canNodeFocus(treeItems, nextIndex) {
|
||||
var _a, _b;
|
||||
const currentNode = store.value.getNode(treeItems[nextIndex].dataset.key);
|
||||
return currentNode.canFocus && currentNode.visible && (((_a = currentNode.parent) == null ? void 0 : _a.expanded) || ((_b = currentNode.parent) == null ? void 0 : _b.level) === 0);
|
||||
}
|
||||
const handleKeydown = (ev) => {
|
||||
const currentItem = ev.target;
|
||||
if (!currentItem.className.includes(ns.b("node")))
|
||||
return;
|
||||
const code = event.getEventCode(ev);
|
||||
const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
|
||||
const currentIndex = treeItems.indexOf(currentItem);
|
||||
let nextIndex;
|
||||
if ([aria.EVENT_CODE.up, aria.EVENT_CODE.down].includes(code)) {
|
||||
ev.preventDefault();
|
||||
if (code === aria.EVENT_CODE.up) {
|
||||
nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.length - 1;
|
||||
const startIndex = nextIndex;
|
||||
while (true) {
|
||||
if (canNodeFocus(treeItems, nextIndex)) {
|
||||
break;
|
||||
}
|
||||
nextIndex--;
|
||||
if (nextIndex === startIndex) {
|
||||
nextIndex = -1;
|
||||
break;
|
||||
}
|
||||
if (nextIndex < 0) {
|
||||
nextIndex = treeItems.length - 1;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.length - 1 ? currentIndex + 1 : 0;
|
||||
const startIndex = nextIndex;
|
||||
while (true) {
|
||||
if (canNodeFocus(treeItems, nextIndex)) {
|
||||
break;
|
||||
}
|
||||
nextIndex++;
|
||||
if (nextIndex === startIndex) {
|
||||
nextIndex = -1;
|
||||
break;
|
||||
}
|
||||
if (nextIndex >= treeItems.length) {
|
||||
nextIndex = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
nextIndex !== -1 && treeItems[nextIndex].focus();
|
||||
}
|
||||
if ([aria.EVENT_CODE.left, aria.EVENT_CODE.right].includes(code)) {
|
||||
ev.preventDefault();
|
||||
currentItem.click();
|
||||
}
|
||||
const hasInput = currentItem.querySelector('[type="checkbox"]');
|
||||
if ([aria.EVENT_CODE.enter, aria.EVENT_CODE.numpadEnter, aria.EVENT_CODE.space].includes(code) && hasInput) {
|
||||
ev.preventDefault();
|
||||
hasInput.click();
|
||||
}
|
||||
};
|
||||
core.useEventListener(el$, "keydown", handleKeydown);
|
||||
const initTabIndex = () => {
|
||||
var _a;
|
||||
if (!el$.value)
|
||||
return;
|
||||
const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
|
||||
const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
|
||||
checkboxItems.forEach((checkbox) => {
|
||||
checkbox.setAttribute("tabindex", "-1");
|
||||
});
|
||||
const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
|
||||
if (checkedItem.length) {
|
||||
checkedItem[0].setAttribute("tabindex", "0");
|
||||
return;
|
||||
}
|
||||
(_a = treeItems[0]) == null ? void 0 : _a.setAttribute("tabindex", "0");
|
||||
};
|
||||
}
|
||||
|
||||
exports.useKeydown = useKeydown;
|
||||
//# sourceMappingURL=useKeydown.js.map
|
||||
Generated
Vendored
+1
File diff suppressed because one or more lines are too long
Generated
Vendored
+9
@@ -0,0 +1,9 @@
|
||||
import type Node from '../model/node';
|
||||
interface Props {
|
||||
node?: Node;
|
||||
accordion: boolean;
|
||||
}
|
||||
export declare function useNodeExpandEventBroadcast(props: Props): {
|
||||
broadcastExpanded: (node?: Node) => void;
|
||||
};
|
||||
export {};
|
||||
Generated
Vendored
+35
@@ -0,0 +1,35 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
var vue = require('vue');
|
||||
var tokens = require('../tokens.js');
|
||||
|
||||
function useNodeExpandEventBroadcast(props) {
|
||||
const parentNodeMap = vue.inject(tokens.TREE_NODE_MAP_INJECTION_KEY, null);
|
||||
const currentNodeMap = {
|
||||
treeNodeExpand: (node) => {
|
||||
var _a;
|
||||
if (props.node !== node) {
|
||||
(_a = props.node) == null ? void 0 : _a.collapse();
|
||||
}
|
||||
},
|
||||
children: []
|
||||
};
|
||||
if (parentNodeMap) {
|
||||
parentNodeMap.children.push(currentNodeMap);
|
||||
}
|
||||
vue.provide(tokens.TREE_NODE_MAP_INJECTION_KEY, currentNodeMap);
|
||||
return {
|
||||
broadcastExpanded: (node) => {
|
||||
if (!props.accordion)
|
||||
return;
|
||||
for (const childNode of currentNodeMap.children) {
|
||||
childNode.treeNodeExpand(node);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
exports.useNodeExpandEventBroadcast = useNodeExpandEventBroadcast;
|
||||
//# sourceMappingURL=useNodeExpandEventBroadcast.js.map
|
||||
Generated
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"useNodeExpandEventBroadcast.js","sources":["../../../../../../../packages/components/tree/src/model/useNodeExpandEventBroadcast.ts"],"sourcesContent":["import { inject, provide } from 'vue'\nimport { TREE_NODE_MAP_INJECTION_KEY } from '../tokens'\n\nimport type Node from '../model/node'\n\ninterface NodeMap {\n treeNodeExpand(node?: Node): void\n children: NodeMap[]\n}\n\ninterface Props {\n node?: Node\n accordion: boolean\n}\n\nexport function useNodeExpandEventBroadcast(props: Props) {\n const parentNodeMap = inject(\n TREE_NODE_MAP_INJECTION_KEY,\n null\n ) as NodeMap | null\n const currentNodeMap: NodeMap = {\n treeNodeExpand: (node) => {\n if (props.node !== node) {\n props.node?.collapse()\n }\n },\n children: [],\n }\n\n if (parentNodeMap) {\n parentNodeMap.children.push(currentNodeMap)\n }\n\n provide(TREE_NODE_MAP_INJECTION_KEY, currentNodeMap)\n\n return {\n broadcastExpanded: (node?: Node): void => {\n if (!props.accordion) return\n for (const childNode of currentNodeMap.children) {\n childNode.treeNodeExpand(node)\n }\n },\n }\n}\n"],"names":["inject","TREE_NODE_MAP_INJECTION_KEY","provide"],"mappings":";;;;;;;AAEO,SAAS,2BAA2B,CAAC,KAAK,EAAE;AACnD,EAAE,MAAM,aAAa,GAAGA,UAAM,CAACC,kCAA2B,EAAE,IAAI,CAAC,CAAC;AAClE,EAAE,MAAM,cAAc,GAAG;AACzB,IAAI,cAAc,EAAE,CAAC,IAAI,KAAK;AAC9B,MAAM,IAAI,EAAE,CAAC;AACb,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE;AAC/B,QAAQ,CAAC,EAAE,GAAG,KAAK,CAAC,IAAI,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;AAC3D,OAAO;AACP,KAAK;AACL,IAAI,QAAQ,EAAE,EAAE;AAChB,GAAG,CAAC;AACJ,EAAE,IAAI,aAAa,EAAE;AACrB,IAAI,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;AAChD,GAAG;AACH,EAAEC,WAAO,CAACD,kCAA2B,EAAE,cAAc,CAAC,CAAC;AACvD,EAAE,OAAO;AACT,IAAI,iBAAiB,EAAE,CAAC,IAAI,KAAK;AACjC,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS;AAC1B,QAAQ,OAAO;AACf,MAAM,KAAK,MAAM,SAAS,IAAI,cAAc,CAAC,QAAQ,EAAE;AACvD,QAAQ,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;AACvC,OAAO;AACP,KAAK;AACL,GAAG,CAAC;AACJ;;;;"}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
import type Node from './node';
|
||||
import type { TreeEmits } from '../tree';
|
||||
import type { RootTreeType, TreeKey, TreeNodeData } from '../tree.type';
|
||||
export declare const NODE_KEY = "$treeNodeId";
|
||||
export declare const markNodeData: (node: Node, data: TreeNodeData | null) => void;
|
||||
export declare const getNodeKey: (key: TreeKey | undefined, data: TreeNodeData) => any;
|
||||
export declare const handleCurrentChange: (store: RootTreeType["store"], emit: TreeEmits, setCurrent: () => void) => void;
|
||||
+30
@@ -0,0 +1,30 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
const NODE_KEY = "$treeNodeId";
|
||||
const markNodeData = function(node, data) {
|
||||
if (!data || data[NODE_KEY])
|
||||
return;
|
||||
Object.defineProperty(data, NODE_KEY, {
|
||||
value: node.id,
|
||||
enumerable: false,
|
||||
configurable: false,
|
||||
writable: false
|
||||
});
|
||||
};
|
||||
const getNodeKey = (key, data) => data == null ? void 0 : data[key || NODE_KEY];
|
||||
const handleCurrentChange = (store, emit, setCurrent) => {
|
||||
const preCurrentNode = store.value.currentNode;
|
||||
setCurrent();
|
||||
const currentNode = store.value.currentNode;
|
||||
if (preCurrentNode === currentNode)
|
||||
return;
|
||||
emit("current-change", currentNode ? currentNode.data : null, currentNode);
|
||||
};
|
||||
|
||||
exports.NODE_KEY = NODE_KEY;
|
||||
exports.getNodeKey = getNodeKey;
|
||||
exports.handleCurrentChange = handleCurrentChange;
|
||||
exports.markNodeData = markNodeData;
|
||||
//# sourceMappingURL=util.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"util.js","sources":["../../../../../../../packages/components/tree/src/model/util.ts"],"sourcesContent":["import type Node from './node'\nimport type { TreeEmits } from '../tree'\nimport type { RootTreeType, TreeKey, TreeNodeData } from '../tree.type'\n\nexport const NODE_KEY = '$treeNodeId'\n\nexport const markNodeData = function (\n node: Node,\n data: TreeNodeData | null\n): void {\n if (!data || data[NODE_KEY]) return\n Object.defineProperty(data, NODE_KEY, {\n value: node.id,\n enumerable: false,\n configurable: false,\n writable: false,\n })\n}\n\nexport const getNodeKey = (key: TreeKey | undefined, data: TreeNodeData) =>\n data?.[key || NODE_KEY]\n\nexport const handleCurrentChange = (\n store: RootTreeType['store'],\n emit: TreeEmits,\n setCurrent: () => void\n) => {\n const preCurrentNode = store.value.currentNode\n setCurrent()\n const currentNode = store.value.currentNode\n if (preCurrentNode === currentNode) return\n\n emit('current-change', currentNode ? currentNode.data : null, currentNode)\n}\n"],"names":[],"mappings":";;;;AAAY,MAAC,QAAQ,GAAG,cAAc;AAC1B,MAAC,YAAY,GAAG,SAAS,IAAI,EAAE,IAAI,EAAE;AACjD,EAAE,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC;AAC7B,IAAI,OAAO;AACX,EAAE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE;AACxC,IAAI,KAAK,EAAE,IAAI,CAAC,EAAE;AAClB,IAAI,UAAU,EAAE,KAAK;AACrB,IAAI,YAAY,EAAE,KAAK;AACvB,IAAI,QAAQ,EAAE,KAAK;AACnB,GAAG,CAAC,CAAC;AACL,EAAE;AACU,MAAC,UAAU,GAAG,CAAC,GAAG,EAAE,IAAI,KAAK,IAAI,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,QAAQ,EAAE;AAC3E,MAAC,mBAAmB,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,UAAU,KAAK;AAChE,EAAE,MAAM,cAAc,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC;AACjD,EAAE,UAAU,EAAE,CAAC;AACf,EAAE,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC;AAC9C,EAAE,IAAI,cAAc,KAAK,WAAW;AACpC,IAAI,OAAO;AACX,EAAE,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC,IAAI,GAAG,IAAI,EAAE,WAAW,CAAC,CAAC;AAC7E;;;;;;;"}
|
||||
Reference in New Issue
Block a user