cnhis-design-vue 3.3.3-beta.3 → 3.3.3-beta.7

package/es/components/select-person/src/SelectPersonRole.vue.d.ts

@@ -0,0 +1,630 @@
+import { ref, PropType } from 'vue';
+import { type TreeOption } from 'naive-ui';
+import { AnyObject } from '../../../shared/types';
+type IKey = string | number;
+type ITreeOption = TreeOption & AnyObject;
+type IWordBook<T> = {
+    parent_id_obj: keyof T;
+    parent_name_obj: keyof T;
+    user_count_obj?: keyof T;
+    filter_key?: string;
+    [key: string]: any;
+};
+type IWordBookChild<T> = {
+    user_id_obj: keyof T;
+    user_name_obj: keyof T;
+    user_expand_keys?: string[];
+};
+type ITag = {
+    key: IKey;
+    [key: string]: any;
+};
+declare const _default: import("vue").DefineComponent<{
+    defaultList: {
+        type: PropType<(IKey | ITag)[]>;
+        default: () => never[];
+    };
+    data: {
+        type: PropType<ITreeOption[]>;
+        default: () => never[];
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchButtonText: {
+        type: StringConstructor;
+        default: string;
+    };
+    wordbook: {
+        type: PropType<IWordBook<ITreeOption>>;
+        default: () => {};
+    };
+    wordbookChild: {
+        type: PropType<IWordBookChild<ITreeOption>>;
+        default: () => {};
+    };
+    showCount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchInner: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchFilter: {
+        type: PropType<AnyObject>;
+        default: () => {};
+    };
+    treeSetting: {
+        type: PropType<ITreeOption>;
+        default: () => {};
+    };
+    queryLoadChildData: {
+        type: PropType<(node: TreeOption) => Promise<AnyObject>>;
+        default: undefined;
+    };
+    queryTreeSearch: {
+        type: PropType<(keyWork: string) => Promise<Array<AnyObject>>>;
+        default: () => Promise<never[]>;
+    };
+    showSelectType: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    roleData: {
+        type: PropType<ITreeOption[]>;
+        default: () => never[];
+    };
+    roleFields: {
+        type: ObjectConstructor;
+        default: () => {
+            label: string;
+            key: string;
+            children: string;
+        };
+    };
+    forceShowSelectAll: {
+        type: BooleanConstructor;
+    };
+    uncheckableField: {
+        type: StringConstructor;
+    };
+    onlyForwardCascade: {
+        type: BooleanConstructor;
+    };
+}, {
+    searchFilterBase: {
+        isOpen: boolean;
+        multiple: boolean;
+        customTitles: string[];
+        itemHeight: number;
+    };
+    labelList: {
+        key: string;
+        label: string;
+    }[];
+    labelListName: any;
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        defaultList: {
+            type: PropType<(IKey | ITag)[]>;
+            default: () => never[];
+        };
+        data: {
+            type: PropType<ITreeOption[]>;
+            default: () => never[];
+        };
+        searchPlaceholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        searchButtonText: {
+            type: StringConstructor;
+            default: string;
+        };
+        wordbook: {
+            type: PropType<IWordBook<ITreeOption>>;
+            default: () => {};
+        };
+        wordbookChild: {
+            type: PropType<IWordBookChild<ITreeOption>>;
+            default: () => {};
+        };
+        showCount: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        showClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        searchInner: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        searchFilter: {
+            type: PropType<AnyObject>;
+            default: () => {};
+        };
+        treeSetting: {
+            type: PropType<ITreeOption>;
+            default: () => {};
+        };
+        queryLoadChildData: {
+            type: PropType<(node: TreeOption) => Promise<AnyObject>>;
+            default: undefined;
+        };
+        queryTreeSearch: {
+            type: PropType<(keyWork: string) => Promise<Array<AnyObject>>>;
+            default: () => Promise<never[]>;
+        };
+        showSelectType: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        roleData: {
+            type: PropType<ITreeOption[]>;
+            default: () => never[];
+        };
+        roleFields: {
+            type: ObjectConstructor;
+            default: () => {
+                label: string;
+                key: string;
+                children: string;
+            };
+        };
+        forceShowSelectAll: {
+            type: BooleanConstructor;
+        };
+        uncheckableField: {
+            type: StringConstructor;
+        };
+        onlyForwardCascade: {
+            type: BooleanConstructor;
+        };
+    }>> & {}>>;
+    emit: any;
+    keyword: import("vue").Ref<string>;
+    checkedAll: import("vue").Ref<boolean>;
+    checkedKeys: import("vue").Ref<IKey[]>;
+    expandedKeys: import("vue").Ref<IKey[]>;
+    treeData: import("vue").Ref<{
+        [x: string]: unknown;
+        key?: import("naive-ui/es/tree/src/interface").Key | undefined;
+        label?: string | undefined;
+        checkboxDisabled?: boolean | undefined;
+        disabled?: boolean | undefined;
+        isLeaf?: boolean | undefined;
+        children?: any[] | undefined;
+        prefix?: (() => import("vue").VNodeChild) | undefined;
+        suffix?: (() => import("vue").VNodeChild) | undefined;
+    }[]>;
+    tagData: import("vue").Ref<{
+        [x: string]: any;
+        key: IKey;
+    }[]>;
+    initTagData: import("vue").Ref<{
+        [x: string]: any;
+        key: IKey;
+    }[]>;
+    isSearch: import("vue").Ref<boolean>;
+    allCheckedTreeKeys: import("vue").Ref<IKey[]>;
+    isRemote: import("vue").ComputedRef<boolean>;
+    checkStrategyResult: import("vue").ComputedRef<any>;
+    isSearchFilter: import("vue").ComputedRef<boolean>;
+    curSelectKey: import("vue").Ref<string>;
+    mergeSearchFilter: import("vue").ComputedRef<{
+        isOpen: boolean;
+        multiple: boolean;
+        customTitles: string[];
+        itemHeight: number;
+    }>;
+    wordbookChildExpandkeys: import("vue").ComputedRef<string[]>;
+    styleObject: import("vue").ComputedRef<{
+        height: string;
+    }>;
+    caculateTagData: import("vue").ComputedRef<any>;
+    treeDataMiddle: any;
+    checkedKeysMiddle: any;
+    checkedTagsMiddle: any;
+    allCheckedKeysMiddle: any;
+    attrType: import("vue").ComputedRef<any>;
+    keyStr: import("vue").ComputedRef<string>;
+    getTreeDataMiddleData: () => void;
+    getDeptData: (list: any[], cb?: any) => any[];
+    getRoleData: (list: any[], cb?: any) => any[];
+    onHandleLabelChange: (item: any) => void;
+    setSelectTagData: (tree: TreeOption[], operatorType: string) => void;
+    uniqArrObj: (arr: any[], name: string) => any;
+    init: () => void;
+    getMainData: (tree: TreeOption[], parentNode: TreeOption | null, cb?: any) => void;
+    setAllCheckedKeys: (tree: TreeOption, cb?: any) => void;
+    setAllCheckedKeysWithChild: (item: TreeOption, cb?: any) => void;
+    setAllCheckedKeysWithParent: (item: TreeOption, cb?: any) => void;
+    setAllCheckedKeysWithAll: (item: TreeOption, cb?: any) => void;
+    queryLoadChildNode: (node: TreeOption) => Promise<AnyObject>;
+    setDisabled: (data: TreeOption) => void;
+    renderLabel: ({ option }: {
+        option: TreeOption;
+    }) => JSX.Element;
+    getLabelName: (option: TreeOption) => {};
+    transformData: (trees: TreeOption[]) => TreeOption[];
+    calculateRootItems: (trees: TreeOption[], items: TreeOption[]) => TreeOption[];
+    transformParentNodeName: (trees: TreeOption[], tempContent: any) => TreeOption[];
+    searchSetting: () => string;
+    onSearch: () => Promise<void>;
+    setTreeCheckd: (tree: TreeOption[], checked: boolean) => void;
+    setCheckdWithChild: (tree: TreeOption[], checked: boolean) => void;
+    setCheckdWithParent: (tree: TreeOption[], checked: boolean) => void;
+    setCheckdWithAll: (tree: TreeOption[], checked: boolean) => void;
+    checkedAllChange: (checked: boolean) => void;
+    uniq: (arr: ITag[]) => ITag[];
+    setTagData: (tree: TreeOption[]) => void;
+    getFlattenKeys: (tree: TreeOption[]) => any[];
+    updateTreeChecked: (keys: Array<IKey>, _: any, meta: {
+        node: TreeOption | null;
+        action: 'check' | 'uncheck';
+    }) => void;
+    setCheckedAll: () => void;
+    clearAll: () => void;
+    closeTag: (tag: ITag) => void;
+    notifyCheck: (keys: IKey[]) => void;
+    notifySearchClear: () => void;
+    getCheckWithLevel: () => any;
+    resetParams: () => void;
+    NButton: any;
+    NInput: any;
+    NInputGroup: any;
+    NCheckbox: any;
+    NTree: any;
+    NTag: any;
+    NIcon: any;
+    NSpace: any;
+    NGrid: any;
+    NGi: any;
+    NEmpty: any;
+    CloseCircleSharp: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    SearchMultiple: import("vue").DefineComponent<{
+        treeData: {
+            type: PropType<any[]>;
+            default: () => never[];
+        };
+        checkedKeys: {
+            type: PropType<(string | number)[]>;
+            default: () => never[];
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            treeData: {
+                type: PropType<any[]>;
+                default: () => never[];
+            };
+            checkedKeys: {
+                type: PropType<(string | number)[]>;
+                default: () => never[];
+            };
+        }>> & {
+            onNotifyCheck?: ((...args: any[]) => any) | undefined;
+        }>>;
+        emit: (event: "notifyCheck", ...args: any[]) => void;
+        optionsRef: import("vue").ComputedRef<any[]>;
+        list: import("vue").Ref<import("@vueuse/core").UseVirtualListItem<any>[]>;
+        containerProps: {
+            ref: import("vue").Ref<any>;
+            onScroll: () => void;
+            style: Partial<CSSStyleDeclaration>;
+        };
+        wrapperProps: import("vue").ComputedRef<{
+            style: {
+                width: string;
+                height: string;
+                marginTop: string;
+            };
+        }>;
+        containerStyleWithHeight: import("vue").ComputedRef<import("vue").CSSProperties>;
+        searchCheckKeys: import("vue").Ref<(string | number)[]>;
+        showSelectKeys: import("vue").Ref<(string | number)[]>;
+        checkedChange: (checkList: (string | number)[], meta: {
+            actionType: "check" | "uncheck";
+            value: string | number;
+        }) => void;
+        handleCheckKey: (baseKeys: (string | number)[], currentTree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        } | null, value: string | number) => false | undefined;
+        findParent: (baseKeys: (string | number)[], currentTree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }) => false | undefined;
+        handleUnCheckKey: (baseKeys: (string | number)[], currentTree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }, value: string | number) => false | undefined;
+        findChild: (baseKeys: (string | number)[], children: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }[], value: string | number) => false | undefined;
+        checkInitTree: (tree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }, baseKey: string | number) => false | undefined;
+        ref: typeof ref;
+        NCheckboxGroup: any;
+        NCheckbox: any;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "notifyCheck"[], "notifyCheck", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        treeData: {
+            type: PropType<any[]>;
+            default: () => never[];
+        };
+        checkedKeys: {
+            type: PropType<(string | number)[]>;
+            default: () => never[];
+        };
+    }>> & {
+        onNotifyCheck?: ((...args: any[]) => any) | undefined;
+    }, {
+        treeData: any[];
+        checkedKeys: (string | number)[];
+    }>;
+    SearchOrgAndStaff: import("vue").DefineComponent<{
+        treeData: {
+            type: PropType<any[]>;
+            default: () => never[];
+        };
+        checkedKeys: {
+            type: PropType<(string | number)[]>;
+            default: () => never[];
+        };
+        searchFilter: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        isMultiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }, {
+        $message: import("naive-ui").MessageApi;
+        virtualItemHeight: number;
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            treeData: {
+                type: PropType<any[]>;
+                default: () => never[];
+            };
+            checkedKeys: {
+                type: PropType<(string | number)[]>;
+                default: () => never[];
+            };
+            searchFilter: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+            isMultiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            onNotifyCheck?: ((...args: any[]) => any) | undefined;
+            onNotifyClear?: ((...args: any[]) => any) | undefined;
+        }>>;
+        emit: (event: "notifyCheck" | "notifyClear", ...args: any[]) => void;
+        moduleHeight: import("vue").ComputedRef<any>;
+        showNums: import("vue").ComputedRef<number>;
+        staffDataRef: import("vue").ComputedRef<any[]>;
+        staffList: import("vue").Ref<import("@vueuse/core").UseVirtualListItem<any>[]>;
+        staffContainerProps: {
+            ref: import("vue").Ref<any>;
+            onScroll: () => void;
+            style: Partial<CSSStyleDeclaration>;
+        };
+        staffWrapperProps: import("vue").ComputedRef<{
+            style: {
+                width: string;
+                height: string;
+                marginTop: string;
+            };
+        }>;
+        staffContainerStyleWithHeight: import("vue").ComputedRef<import("vue").CSSProperties>;
+        orgDataRef: import("vue").ComputedRef<any[]>;
+        orgList: import("vue").Ref<import("@vueuse/core").UseVirtualListItem<any>[]>;
+        orgContainerProps: {
+            ref: import("vue").Ref<any>;
+            onScroll: () => void;
+            style: Partial<CSSStyleDeclaration>;
+        };
+        orgWrapperProps: import("vue").ComputedRef<{
+            style: {
+                width: string;
+                height: string;
+                marginTop: string;
+            };
+        }>;
+        orgContainerStyleWithHeight: import("vue").ComputedRef<import("vue").CSSProperties>;
+        searchCheckKeys: import("vue").Ref<(string | number)[]>;
+        showSelectKeys: import("vue").Ref<(string | number)[]>;
+        handleClick: (tree: any) => void;
+        handleStaffClick: (baseKeys: (string | number)[], currentTree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }, value: string | number) => false | undefined;
+        findParent: (baseKeys: (string | number)[], currentTree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }) => false | undefined;
+        handleOrgClick: (baseKeys: (string | number)[], currentTree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }, value: string | number) => void;
+        handleFindChildren: (treeList: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }[]) => void;
+        checkInitTree: (tree: {
+            [key: string]: any;
+            key: string | number;
+            children: any[];
+            parentNode: any;
+        }, baseKey: string | number) => false | undefined;
+        ref: typeof ref;
+        NEmpty: any;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("notifyCheck" | "notifyClear")[], "notifyCheck" | "notifyClear", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        treeData: {
+            type: PropType<any[]>;
+            default: () => never[];
+        };
+        checkedKeys: {
+            type: PropType<(string | number)[]>;
+            default: () => never[];
+        };
+        searchFilter: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        isMultiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        onNotifyCheck?: ((...args: any[]) => any) | undefined;
+        onNotifyClear?: ((...args: any[]) => any) | undefined;
+    }, {
+        searchFilter: Record<string, any>;
+        treeData: any[];
+        checkedKeys: (string | number)[];
+        isMultiple: boolean;
+    }>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    defaultList: {
+        type: PropType<(IKey | ITag)[]>;
+        default: () => never[];
+    };
+    data: {
+        type: PropType<ITreeOption[]>;
+        default: () => never[];
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchButtonText: {
+        type: StringConstructor;
+        default: string;
+    };
+    wordbook: {
+        type: PropType<IWordBook<ITreeOption>>;
+        default: () => {};
+    };
+    wordbookChild: {
+        type: PropType<IWordBookChild<ITreeOption>>;
+        default: () => {};
+    };
+    showCount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchInner: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchFilter: {
+        type: PropType<AnyObject>;
+        default: () => {};
+    };
+    treeSetting: {
+        type: PropType<ITreeOption>;
+        default: () => {};
+    };
+    queryLoadChildData: {
+        type: PropType<(node: TreeOption) => Promise<AnyObject>>;
+        default: undefined;
+    };
+    queryTreeSearch: {
+        type: PropType<(keyWork: string) => Promise<Array<AnyObject>>>;
+        default: () => Promise<never[]>;
+    };
+    showSelectType: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    roleData: {
+        type: PropType<ITreeOption[]>;
+        default: () => never[];
+    };
+    roleFields: {
+        type: ObjectConstructor;
+        default: () => {
+            label: string;
+            key: string;
+            children: string;
+        };
+    };
+    forceShowSelectAll: {
+        type: BooleanConstructor;
+    };
+    uncheckableField: {
+        type: StringConstructor;
+    };
+    onlyForwardCascade: {
+        type: BooleanConstructor;
+    };
+}>>, {
+    data: ITreeOption[];
+    defaultList: (IKey | ITag)[];
+    searchPlaceholder: string;
+    searchButtonText: string;
+    wordbook: IWordBook<ITreeOption>;
+    wordbookChild: IWordBookChild<ITreeOption>;
+    showCount: boolean;
+    showClear: boolean;
+    multiple: boolean;
+    searchInner: boolean;
+    searchFilter: AnyObject;
+    treeSetting: ITreeOption;
+    queryLoadChildData: (node: TreeOption) => Promise<AnyObject>;
+    queryTreeSearch: (keyWork: string) => Promise<Array<AnyObject>>;
+    showSelectType: boolean;
+    roleData: ITreeOption[];
+    roleFields: Record<string, any>;
+    forceShowSelectAll: boolean;
+    onlyForwardCascade: boolean;
+}>;
+export default _default;

package/es/components/select-person/src/{SelectPerson.vue.js → SelectPersonRole.vue.js}

@@ -1,6 +1,6 @@
-import _sfc_main from './SelectPerson.vue2.js';
+import _sfc_main from './SelectPersonRole.vue2.js';
 import _export_sfc from '../../../_virtual/_plugin-vue_export-helper.js';
 
-var SelectPerson = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "SelectPerson.vue"]]);
+var SelectPerson = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "SelectPersonRole.vue"]]);
 
 export { SelectPerson as default };

package/es/components/select-person/src/{SelectPerson.vue2.js → SelectPersonRole.vue2.js}

@@ -23,7 +23,7 @@ const _hoisted_4 = {
   key: 0
 };
 var _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "SelectPerson",
+  __name: "SelectPersonRole",
   props: {
     defaultList: {
       type: Array,

package/es/components/select-person/src/index.vue2.js

@@ -1,7 +1,7 @@
 import { defineComponent, useAttrs, ref, computed, provide, openBlock, createBlock, resolveDynamicComponent, unref, mergeProps, withCtx, createCommentVNode, renderSlot, normalizeProps, guardReactiveProps } from 'vue';
 import { InjectionSelectPersonEmits } from './constants/index.js';
 import SelectPersonType from './SelectPersonType.vue.js';
-import SelectPerson from './SelectPerson.vue.js';
+import SelectPerson from './SelectPersonRole.vue.js';
 
 var _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "index",
@@ -126,8 +126,8 @@ var _sfc_main = /* @__PURE__ */ defineComponent({
     const $attrs = useAttrs();
     const selectPersonRef = ref();
     const isComponent = computed(() => {
-      var _a;
-      return ((_a = props.switchTypeProps) == null ? void 0 : _a.length) > 0 ? SelectPersonType : SelectPerson;
+      var _a, _b;
+      return ((_a = props.switchTypeProps) == null ? void 0 : _a.length) > 0 ? SelectPersonType : ((_b = props == null ? void 0 : props.roleData) == null ? void 0 : _b.length) ? SelectPerson : SelectPerson;
     });
     const getProps = computed(() => {
       return Object.assign({}, props, $attrs);

package/es/components/select-person/src/utils/index.js

@@ -1,24 +1,22 @@
-import { cloneDeep } from 'lodash-es';
 import { SearchTypeConfig } from '../types/enums.js';
 
 function searchFilterTree(attr, data, keyword, filterKey) {
-  const newData = cloneDeep(data);
   if (keyword.trim()) {
     let filterSearchValue = [];
     switch (attr) {
       case SearchTypeConfig.SEARCH_ORG_STAFF:
-        filterSearchValue = getOrgAndStaffByName(newData, keyword, filterKey);
+        filterSearchValue = getOrgAndStaffByName(data, keyword, filterKey);
         break;
       case SearchTypeConfig.SEARCH_ORG:
-        filterSearchValue = getStaffByName(newData, keyword, filterKey);
+        filterSearchValue = getStaffByName(data, keyword, filterKey);
         break;
       default:
-        filterSearchValue = searchBasisTree(newData, keyword, filterKey);
+        filterSearchValue = searchBasisTree(data, keyword, filterKey);
         break;
     }
     return filterSearchValue;
   }
-  return searchBasisTree(newData, keyword, filterKey);
+  return searchBasisTree(data, keyword, filterKey);
 }
 function searchBasisTree(data, keyword, filterKey) {
   transform(data, keyword, filterKey);