vap1 0.0.1

package/components/Tables/VTable.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VTable = exports.getHeightByTagName = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importStar(require("react"));
+const antd_1 = require("antd");
+const ActionBar_1 = require("./Components/ActionBar");
+const utils_1 = require("../../utils");
+const Util_1 = require("./Util");
+const HighLight_1 = require("../_common/HighLight");
+const hooks_1 = require("../../hooks");
+const Box_1 = require("../Box/Box");
+const getHeightByTagName = (root, tagName) => {
+    if (root == null)
+        return 0;
+    let els = root.getElementsByTagName(tagName);
+    if (els.length) {
+        return els[0].getBoundingClientRect().height;
+    }
+    return 0;
+};
+exports.getHeightByTagName = getHeightByTagName;
+const _VTable = react_1.default.forwardRef((props, ref) => {
+    const update = (0, hooks_1.useUpdate)();
+    const { state, root, resize } = (0, Box_1.useBox)();
+    const [scroll, setScroll] = (0, react_1.useState)(undefined);
+    const { rowKey, list, isQuerying, pageNo, pageSize, orderBy, query } = props.model;
+    let start = (0, react_1.useRef)(0);
+    const tableProps = {};
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (state.selected == null)
+            return;
+        if (lodash_1.default.isFunction((_a = props.selectBar) === null || _a === void 0 ? void 0 : _a.onSelect)) {
+            let param = props.selectBar.onSelect(...state.selected);
+            query(Object.assign(Object.assign({}, props.default), param));
+        }
+    }, [state.selected]);
+    // 更新页数
+    (0, react_1.useEffect)(() => { start.current = pageSize * (pageNo - 1); }, [pageSize, pageNo]);
+    // 计算 clolum
+    const columns = (0, react_1.useMemo)(() => {
+        let cols = [];
+        if (props.showIndex !== false)
+            cols.push((0, Util_1.getIdxColumn)(start, props.showIndex));
+        let HighKeys = new Set();
+        if (!utils_1.GLOBAL.CONFIG.SEARCHBAR.DISABLE_KEYWORD && lodash_1.default.has(props, 'searchBar.keyword')) {
+            if (lodash_1.default.isObject(props.searchBar.keyword)) {
+                (props.searchBar.keyword.highlight || []).map(key => HighKeys.add(key));
+            }
+            else {
+                props.columns.map(col => {
+                    if (lodash_1.default.isString(col.dataIndex))
+                        HighKeys.add(col.dataIndex);
+                });
+            }
+        }
+        props.columns.map(col => {
+            if (col.roleCode && !utils_1.PageUtil.hasRole(col.roleCode))
+                return;
+            let item = Object.assign({}, col);
+            if (col.ik) {
+                let title = utils_1.i18n.txt(col.ik);
+                item.title = title == '' ? item.title : title;
+            }
+            if (HighKeys.has(item.dataIndex) && item.render == null) {
+                item.render = (record) => {
+                    if (!lodash_1.default.isString(record))
+                        return record;
+                    let keyword = '';
+                    if (record && keyword) {
+                        return react_1.default.createElement(HighLight_1.HighLight, { text: record, keyword: keyword });
+                    }
+                    return record;
+                };
+            }
+            if (!lodash_1.default.has(item, 'ellipsis'))
+                item.ellipsis = true;
+            if (!lodash_1.default.has(item, 'width') && lodash_1.default.isString(item.title)) {
+                let clz = item.title.length + (item.sorter ? 2 : 0);
+                if (col.className) {
+                    item.className = 'c-table-col-' + clz + ' ' + col.className;
+                }
+                else {
+                    item.className = 'c-table-col-' + clz;
+                }
+            }
+            cols.push(item);
+        });
+        return cols;
+    }, [props.columns]);
+    (0, react_1.useLayoutEffect)(() => {
+        resize();
+    }, [columns]);
+    (0, react_1.useEffect)(() => {
+        if (props.autoLoad === false)
+            return;
+        // @ts-ignore
+        if (lodash_1.default.has(props.selectBar, 'config.mustSelect') && props.selectBar.config['mustSelect'])
+            return;
+        query(props.default || {});
+    }, []);
+    // 更新高度 table 需要把 head 排除设置滚动
+    (0, react_1.useEffect)(() => {
+        if (props.scroll === null)
+            return;
+        if (props.mode == undefined || props.mode == 'common')
+            return;
+        let height = state === null || state === void 0 ? void 0 : state.height;
+        if (!height)
+            return;
+        setTimeout(() => {
+            height -= (0, exports.getHeightByTagName)(root.current, 'thead');
+            setScroll({ y: Math.ceil(height), x: true });
+        }, 2);
+    }, [state === null || state === void 0 ? void 0 : state.height]);
+    // @ts-ignore
+    const effectKey = props.model.effect;
+    (0, react_1.useEffect)(() => {
+        if (effectKey == null)
+            return;
+        let effectRow = effectKey;
+        if (lodash_1.default.isString(effectKey) && lodash_1.default.startsWith(effectKey, '_'))
+            effectRow = effectRow.substring(1);
+        const trs = root.current.getElementsByClassName('ant-table-row');
+        let size = trs.length;
+        if (size <= 0)
+            return;
+        for (let i = 0; i < size; i++) {
+            let tr = trs.item(i);
+            let key = tr.getAttribute('data-row-key');
+            if (key == effectRow) {
+                if (tr.classList.contains('c-table-high')) {
+                    tr.classList.remove('c-table-high');
+                }
+                setTimeout(() => tr.classList.add('c-table-high'), 2);
+            }
+        }
+    }, [effectKey]);
+    if (props.select) {
+        tableProps.rowSelection = {
+            selectedRowKeys: ref.current.selected[0],
+            onChange: (selectedRowKeys, selectedObjects) => {
+                ref.current.selected = [selectedRowKeys, selectedObjects];
+                ref.current.onSelected();
+                update();
+            },
+            getCheckboxProps: record => {
+                if (!lodash_1.default.has(record, rowKey))
+                    return { disabled: true };
+                return { disabled: false };
+            },
+        };
+    }
+    return react_1.default.createElement(antd_1.Table, Object.assign({ rowKey: props.rowKey || rowKey, scroll: scroll, tableLayout: "fixed", 
+        // showSorterTooltip={false}
+        size: utils_1.GLOBAL.CONFIG.TABLE.SIZE }, props, tableProps, { className: utils_1.StringUtil.className(['c-table'], props.className), pagination: false, columns: columns, locale: { emptyText: react_1.default.createElement(antd_1.Empty, { style: { marginTop: 24 } }) }, dataSource: list, loading: isQuerying, onChange: (x, y, field) => {
+            if (field.column) {
+                orderBy(field.field, field.order == 'ascend' ? 'asc' : 'desc');
+            }
+            else {
+                orderBy(null, 'desc');
+            }
+        } }));
+});
+const VTable = (props) => {
+    const { isQuerying, pageNo, pageSize, total, totalAcc, param, pageTo, query, cost } = props.model;
+    // 通过 ref 方式交互，后续扩展方法实现定制联页选择
+    const selectedRef = (0, react_1.useRef)({ selected: [[], []], onSelected: () => { }, });
+    let boxProps = lodash_1.default.pick(props, ['selectBar', 'style', 'className', 'default', 'mode']);
+    if (props.searchBar) {
+        boxProps.searchBar = Object.assign(Object.assign({}, props.searchBar), { disabled: isQuerying, onSearch: (data) => {
+                let queryParam = lodash_1.default.extend({}, param, data);
+                query(queryParam, true);
+                selectedRef.current.selected = [[], []];
+                selectedRef.current.onSelected();
+            } });
+    }
+    if (props.actionBar) {
+        if (lodash_1.default.isArray(props.actionBar)) {
+            if (props.actionBar.length) {
+                boxProps.actionBar = react_1.default.createElement(ActionBar_1.ActionBar, { buttons: props.actionBar, queryParam: param, selectedRef: selectedRef });
+            }
+        }
+        else {
+            boxProps.actionBar = props.actionBar;
+        }
+    }
+    if (props.pagination !== false) {
+        boxProps.pagination = {
+            disabled: isQuerying,
+            current: pageNo,
+            pageSize: pageSize,
+            total: total,
+            cost: cost,
+            totalAcc: totalAcc,
+            onChange: pageTo,
+        };
+        if (props.pagination) {
+            if (props.pagination.hideOnSinglePage) {
+                boxProps.pagination.hideOnSinglePage = true;
+            }
+            if (props.pagination.className) {
+                boxProps.pagination.className = props.pagination.className;
+            }
+        }
+    }
+    return react_1.default.createElement(Box_1.Box, Object.assign({}, boxProps),
+        react_1.default.createElement(_VTable, Object.assign({}, lodash_1.default.omit(props, ['className', 'style']), { ref: selectedRef })));
+};
+exports.VTable = VTable;

package/components/Tables/index.d.ts

@@ -0,0 +1,81 @@
+import React from 'react';
+import type { TableDefined } from './Components';
+import type { ForwardRefExoticComponent, ExoticComponent } from 'react';
+import type { TableProps } from 'antd/es/table';
+import type { ColumnProps } from 'antd/es/table/interface';
+import type { SearchBarProps } from '../SearchBar/index';
+import type { TableActionButton } from './Components/ActionBar';
+import type { PlainObject, BaseItem, ApiModel } from '../../basetype';
+import type { BoxMode } from '../Box/Box';
+import type { SelectBarProps } from '../Box/SelectBar';
+export type TableColumn = BaseItem & ColumnProps<PlainObject>;
+/**
+ * 说明：为保持各应用 一致性 与 简单性
+ * 所有VAP组装 Table 排除一些自定义属性
+*/
+export type TableDefine = Omit<TableProps<PlainObject>, 'size' | 'columns' | 'dataSource' | 'bordered' | 'tableLayout' | 'rowKey' | 'title' | 'loading' | 'onChange' | 'rowSelection' | 'getPopupContainer' | 'sortDirections' | 'showSorterTooltip' | 'internalHooks' | 'transformColumns' | 'internalRefs'>;
+export type BaseTableProps = TableDefine & {
+    mode?: BoxMode;
+    /**
+     * 列
+    */
+    columns: TableColumn[];
+    /**
+     * 序号字段
+     * 1. 不传   ：显示序号 , 支持国际化
+     * 2. 传 false ：不显示 序号
+     * 3. 传指定标题 ：显示指定标题
+     */
+    showIndex?: false | string;
+    /**
+     * 说明：强制使用 String 类型 ROW KEY
+    */
+    rowKey?: string;
+    /**
+     * 允许选择, 默认不允许
+     *
+     * 说明
+     * 1. 传 true 或 DEFAULT  时，为默认选择模式
+     * 2. 说明：后续支持 ： 传 QUERY 时，为查询内选择 ： 即：“翻页连选”，当查询条件变化时会清除已选项
+     *
+    */
+    select?: true | 'DEFAULT' | 'QUERY';
+    /**
+     * 禁止选中的条件return true 禁止选中
+     */
+    selectDisabled?: (record: any) => boolean;
+    /**
+     * 表格操作区域
+    */
+    actionBar?: (TableActionButton[]) | React.ReactNode;
+    /**
+     * 表格选择区域
+    */
+    selectBar?: SelectBarProps;
+    /**
+     * 表格搜索区域
+    */
+    searchBar?: Omit<SearchBarProps, 'onChange' | 'onSearch'>;
+    /**
+     * 默认查询参数
+    */
+    default?: PlainObject;
+    /**
+    * 是否自动查询，默认为TRUE
+   */
+    autoLoad?: false;
+};
+import type { ApiTableProps } from './ApiTable';
+export type ApiTable = ForwardRefExoticComponent<ApiTableProps & React.RefAttributes<ApiModel>> & TableDefined;
+export declare const ApiTable: ApiTable;
+import type { VTableProps } from './VTable';
+export type VTable = ExoticComponent<VTableProps> & TableDefined;
+export declare const VTable: VTable;
+import type { STableProps } from './STable';
+export type STable = ExoticComponent<STableProps> & TableDefined;
+export declare const STable: STable;
+import type { TopTableProps } from './TopTable';
+export type TopTable = ExoticComponent<TopTableProps> & TableDefined;
+export declare const TopTable: TopTable;
+export { TopTableModal } from './TopTableModal';
+export { ApiTableModal } from './ApiTableModal';

package/components/Tables/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTableModal = exports.TopTableModal = exports.TopTable = exports.STable = exports.VTable = exports.ApiTable = void 0;
+const Components_1 = require("./Components");
+const ApiTable_1 = require("./ApiTable");
+exports.ApiTable = ApiTable_1.ApiTable;
+(0, Components_1.defineTable)(exports.ApiTable);
+const VTable_1 = require("./VTable");
+exports.VTable = VTable_1.VTable;
+(0, Components_1.defineTable)(exports.VTable);
+const STable_1 = require("./STable");
+exports.STable = STable_1.STable;
+(0, Components_1.defineTable)(exports.STable);
+const TopTable_1 = require("./TopTable");
+exports.TopTable = TopTable_1.TopTable;
+(0, Components_1.defineTable)(exports.TopTable);
+var TopTableModal_1 = require("./TopTableModal");
+Object.defineProperty(exports, "TopTableModal", { enumerable: true, get: function () { return TopTableModal_1.TopTableModal; } });
+var ApiTableModal_1 = require("./ApiTableModal");
+Object.defineProperty(exports, "ApiTableModal", { enumerable: true, get: function () { return ApiTableModal_1.ApiTableModal; } });

package/components/TreeSelect/BaseTreeSelect.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { Language } from '../../utils/_Support';
+import type { TreeNodeData } from '../../utils/TreeUtil';
+import type { TreeSelectProps } from 'antd/es/tree-select';
+import type { AntTreeNodeProps } from 'antd/es/tree';
+import type { PropsWithChildren } from 'react';
+import type { BaseTreeSelectProps } from './index';
+import type { PlainObject } from '../../basetype';
+export type BaseTreeSelectState = {
+    baseProps: TreeSelectProps<any>;
+    treeData: TreeNodeData[];
+    keyField: string;
+    titleField: string;
+    valueField: string;
+    rootCode?: string | number;
+    langs: {
+        lang: Language;
+        field: string;
+    }[];
+};
+type BaseTreeSelectContext = {
+    treeState: BaseTreeSelectState;
+    setTreeData: (treeData: TreeNodeData[]) => void;
+    onSelect: TreeSelectProps<any>['onSelect'];
+    onChange: TreeSelectProps<any>['onChange'];
+};
+declare const BaseTreeSelectContext: React.Context<BaseTreeSelectContext>;
+export declare const useBaseTree: () => BaseTreeSelectContext;
+export declare const BaseTreeSelect: React.FC<PropsWithChildren<BaseTreeSelectProps>>;
+export declare const getNodeParam: (node: any, state: BaseTreeSelectState, disabledNode: (node: PlainObject) => boolean) => AntTreeNodeProps;
+export declare const renderRoot: (props: BaseTreeSelectProps, state: BaseTreeSelectState) => React.ReactNode;
+export declare const getData: (api: string, notCache: boolean) => Promise<PlainObject[]>;
+export {};

package/components/TreeSelect/BaseTreeSelect.js

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getData = exports.renderRoot = exports.getNodeParam = exports.BaseTreeSelect = exports.useBaseTree = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importStar(require("react"));
+const antd_1 = require("antd");
+const utils_1 = require("../../utils");
+const hooks_1 = require("../../hooks");
+const _Support_1 = require("../../utils/_Support");
+const BaseTreeSelectContext = (0, react_1.createContext)(null);
+const useBaseTree = () => (0, react_1.useContext)(BaseTreeSelectContext);
+exports.useBaseTree = useBaseTree;
+const BaseTreeSelect = (props) => {
+    const clazz = utils_1.StringUtil.className(['c-tree'], props.className);
+    const basePropsKeys = [
+        'defaultValue',
+        'multiple',
+        'treeDefaultExpandAll',
+        'treeCheckable',
+        'disabled',
+        'showSearch',
+        'style'
+    ];
+    const stateKeys = [
+        'rootCode',
+        'keyField',
+        'valueField',
+        // 'parentField'
+    ];
+    const DEFAULT = {
+        baseProps: {
+            dropdownStyle: { maxHeight: 400, overflow: 'auto' },
+            showSearch: true,
+            allowClear: true,
+            className: clazz,
+            style: { width: '300px' },
+            treeNodeFilterProp: 'title',
+        },
+        treeData: [],
+        rootCode: '0',
+        titleField: 'name',
+        keyField: 'id',
+        valueField: null,
+        // parentField: null,
+        langs: null,
+    };
+    lodash_1.default.forEach(stateKeys, (k) => {
+        if (props[k] != null) {
+            DEFAULT[k] = props[k];
+        }
+    });
+    lodash_1.default.forEach(basePropsKeys, (k) => {
+        if (props[k] != null) {
+            DEFAULT.baseProps[k] = props[k];
+        }
+    });
+    if (lodash_1.default.isString(props.titleField)) {
+        DEFAULT.titleField = props.titleField;
+    }
+    else {
+        let langs = [];
+        if (props.titleField.zhCN) {
+            langs.push({ lang: _Support_1.Language.ZH_CN, field: props.titleField.zhCN });
+            if (utils_1.GLOBAL.CONFIG.APP.LANG == _Support_1.Language.ZH_CN) {
+                DEFAULT.titleField = props.titleField.zhCN;
+            }
+        }
+        if (props.titleField.enUS) {
+            langs.push({ lang: _Support_1.Language.EN_US, field: props.titleField.enUS });
+            if (utils_1.GLOBAL.CONFIG.APP.LANG == _Support_1.Language.EN_US) {
+                DEFAULT.titleField = props.titleField.enUS;
+            }
+        }
+        if (props.titleField.zhHK) {
+            langs.push({ lang: _Support_1.Language.ZH_HK, field: props.titleField.zhHK });
+            if (utils_1.GLOBAL.CONFIG.APP.LANG == _Support_1.Language.ZH_HK) {
+                DEFAULT.titleField = props.titleField.zhHK;
+            }
+        }
+        if (langs.length > 1) {
+            DEFAULT.langs = langs;
+        }
+    }
+    const [state, setState] = (0, hooks_1.useSetState)(DEFAULT);
+    const setTreeData = (treeData) => setState({ treeData: [...treeData] });
+    const onSelect = (0, react_1.useCallback)((value, info, extra) => {
+        const data = info.data.node;
+        if (props.onSelect) {
+            props.onSelect(value, data[DEFAULT.keyField], data);
+        }
+    }, [state.treeData]);
+    const onChange = (0, react_1.useCallback)((value, labelList, extra) => {
+        let nodes = [];
+        if (value.length > 0) {
+            const allCheckedNodes = extra.allCheckedNodes;
+            allCheckedNodes.forEach(({ pos, node }) => {
+                nodes.push(Object.assign({ pos }, node.props.data.node));
+            });
+        }
+        if (lodash_1.default.isFunction(props.onChange)) {
+            props.onChange(value, labelList, nodes);
+        }
+    }, [state.treeData]);
+    return react_1.default.createElement(BaseTreeSelectContext.Provider, { value: { treeState: state, setTreeData, onSelect, onChange } }, props.children);
+};
+exports.BaseTreeSelect = BaseTreeSelect;
+const getNodeParam = (node, state, disabledNode) => {
+    const { titleField, keyField, valueField, } = state;
+    let param = { key: node[keyField], data: { node }, value: node[valueField] };
+    param.title = node[titleField];
+    if (lodash_1.default.isFunction(disabledNode)) {
+        if (disabledNode(node)) {
+            param.disabled = true;
+        }
+    }
+    return param;
+};
+exports.getNodeParam = getNodeParam;
+const renderNode = (node, state, props) => {
+    const param = (0, exports.getNodeParam)(node, state, props.disabledNode);
+    if (lodash_1.default.isArray(node.children) && node.children.length) {
+        return react_1.default.createElement(antd_1.TreeSelect.TreeNode, Object.assign({}, param, { isLeaf: false }), renderNodes(node.children, state, props));
+    }
+    let isLeaf = true;
+    if (props.checkField) {
+        isLeaf = !node[props.checkField];
+    }
+    return react_1.default.createElement(antd_1.TreeSelect.TreeNode, Object.assign({}, param, { isLeaf: isLeaf }));
+};
+const renderNodes = (data, state, props) => data.map((item) => renderNode(item, state, props));
+const renderRoot = (props, state) => renderNodes(state.treeData, state, props);
+exports.renderRoot = renderRoot;
+const getResponseList = (resp) => {
+    let data;
+    if (lodash_1.default.has(resp, 'data')) {
+        data = resp.data;
+    }
+    else if (lodash_1.default.has(resp, 'list')) {
+        data = resp.list;
+    }
+    else {
+        data = [];
+    }
+    if (lodash_1.default.isArray(data)) {
+        return data;
+    }
+    return [data];
+};
+const getData = (api, notCache) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!notCache)
+        utils_1.Ajax.SESSION(api);
+    const resp = yield utils_1.Ajax.GET(api);
+    return getResponseList(resp);
+});
+exports.getData = getData;

package/components/TreeSelect/DTreeSelect.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { BaseTreeSelectProps } from './index';
+import type { Key, PlainObject } from '../../basetype';
+export type DTreeProps = {
+    /**
+     * 根节点API 与rootCode 二选一
+    */
+    rootApi?: string;
+    /**
+     * 展开子节点：
+     *
+     * 方式一：传一个 api 接口地址，必须返回 VData<Array<Object>> 格式
+     *
+     * 方式二：传一个方法 ，接收一个父节点参数，必须返回  Promise<TreeNodeData[]> (不要返回 children, 仅返回一级)
+    */
+    childApi: string | ((parentId: Key) => Promise<PlainObject[]>);
+    /**
+     * 接口是否缓存
+     */
+    notCache?: boolean;
+};
+type DTreeSelectProps = BaseTreeSelectProps & DTreeProps;
+export declare const DTreeSelect: React.FC<DTreeSelectProps>;
+export {};

package/components/TreeSelect/DTreeSelect.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTreeSelect = void 0;
+const react_1 = __importDefault(require("react"));
+const antd_1 = require("antd");
+const lodash_1 = __importDefault(require("lodash"));
+const BaseTreeSelect_1 = require("./BaseTreeSelect");
+const hooks_1 = require("../../hooks");
+const _DTreeSelect = (props) => {
+    const { treeState, setTreeData, onChange, onSelect } = (0, BaseTreeSelect_1.useBaseTree)();
+    const { rootApi, notCache, childApi } = props;
+    (0, hooks_1.useEffectFunction)(() => __awaiter(void 0, void 0, void 0, function* () {
+        let treeData = [];
+        if (rootApi) {
+            treeData = yield (0, BaseTreeSelect_1.getData)(rootApi, notCache);
+        }
+        else if (lodash_1.default.isFunction(props.childApi)) {
+            treeData = yield props.childApi(treeState.rootCode);
+        }
+        else {
+            treeData = yield (0, BaseTreeSelect_1.getData)(childApi + treeState.rootCode, notCache);
+        }
+        if (treeData.length == 1) {
+            treeData[0].children = yield (0, BaseTreeSelect_1.getData)(childApi + treeData[0][treeState.keyField], notCache);
+        }
+        setTreeData(treeData);
+    }), []);
+    const treeProps = {};
+    if (treeState.treeData.length == 1) {
+        // 如果根节点只有一个，则自动展开这个根结点
+        const key = treeState.treeData[0][treeState.keyField];
+        treeProps.treeDefaultExpandedKeys = [key];
+        // treeProps.treeLoadedKeys = [key];
+    }
+    const loadData = (dataNode) => __awaiter(void 0, void 0, void 0, function* () {
+        return new Promise((r) => __awaiter(void 0, void 0, void 0, function* () {
+            const { node } = dataNode.data;
+            const API = props.childApi + node[treeState.keyField];
+            const children = yield (0, BaseTreeSelect_1.getData)(API, notCache);
+            console.log('dataNode', dataNode);
+            const pathArr = dataNode.pos.split('-');
+            pathArr.splice(0, 1);
+            let nodePath = pathArr.map(i => `[${i}]`).join('.children');
+            const data = lodash_1.default.get(treeState.treeData, nodePath);
+            data.children = children;
+            setTreeData(treeState.treeData);
+            r(undefined);
+        }));
+    });
+    return react_1.default.createElement(antd_1.TreeSelect, Object.assign({}, treeState.baseProps, treeProps, { disabled: props.disabled, loadData: loadData, onChange: onChange, onSelect: onSelect }), (0, BaseTreeSelect_1.renderRoot)(props, treeState));
+};
+const DTreeSelect = (props) => react_1.default.createElement(BaseTreeSelect_1.BaseTreeSelect, Object.assign({}, props),
+    react_1.default.createElement(_DTreeSelect, Object.assign({}, props)));
+exports.DTreeSelect = DTreeSelect;

package/components/TreeSelect/FTreeSelect.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { BaseTreeSelectProps } from './index';
+export type FTreeFetch = {
+    /**
+     * 获取数据的接口地址
+    */
+    api?: string;
+};
+type FTreeSelectProps = BaseTreeSelectProps & FTreeFetch;
+export declare const FTreeSelect: React.FC<FTreeSelectProps>;
+export {};