@gct-paas/design 0.1.4-dev.1 → 0.1.4-dev.11

package/es/components/field-transfer/components/Transfer/TransferTree.mjs

@@ -0,0 +1,117 @@
+import { defineComponent, toRefs, ref, computed, createVNode } from 'vue';
+import { Input, Empty, Tree } from 'ant-design-vue';
+import { t, FieldIconMap } from '@gct-paas/core';
+import TreeItem from './TreeItem.mjs';
+import { traverseFilter } from '../../utils/tree-tool.mjs';
+import '../../less/TransferTree.css';/* empty css                            */
+
+const TransferTree = /* @__PURE__ */ defineComponent({
+  name: 'TransferTree',
+  props: {
+    /** useTreeData */
+    treeObj: {
+      type: Object,
+      required: true
+    },
+    checkedKeys: {
+      type: Array,
+      required: true
+    },
+    onCheckedKeysChange: {
+      type: Function,
+      required: true
+    }
+  },
+  setup(props) {
+    const {
+      data,
+      draggable
+    } = toRefs(props.treeObj);
+    const keyword = ref('');
+    const filteredTreeData = computed(() => {
+      if (!keyword.value) {
+        return data.value;
+      }
+      const nodes = traverseFilter(node => node.title.toLowerCase().includes(keyword.value.toLowerCase()), data.value);
+      return nodes;
+    });
+    const handleCheckedKeys = keys => {
+      if (!keyword.value) {
+        props.onCheckedKeysChange(keys);
+        return;
+      }
+      const nextKeys = keys.concat(props.checkedKeys.filter(key => !keys.includes(key) && !filteredTreeData.value.some(item => item.key === key)));
+      props.onCheckedKeysChange(nextKeys);
+    };
+    const slots = {
+      title: node => {
+        return createVNode(TreeItem, {
+          "node": node,
+          "draggable": draggable.value
+        }, null);
+      }
+    };
+    return () => {
+      return createVNode("div", {
+        "class": "transfer-tree-container"
+      }, [createVNode("div", {
+        "class": "search-container"
+      }, [createVNode(Input, {
+        "placeholder": t('sys.component.fieldTransfer.pleaseSearch'),
+        "value": keyword.value,
+        "onChange": e => keyword.value = e.target.value,
+        "allowClear": true,
+        "prefix": createVNode("i", {
+          "class": ['search-icon iconfont', ' icon-sousuo']
+        }, null)
+      }, null)]), createVNode("div", {
+        "class": "tree-wrapper",
+        "style": {
+          overflow: 'auto'
+        }
+      }, [filteredTreeData.value.length === 0 ? createVNode("div", {
+        "class": "empty-container"
+      }, [createVNode(Empty, {
+        "description": keyword.value ? t('sys.component.fieldTransfer.noSearchData') : t('sys.component.fieldTransfer.noData')
+      }, null)]) : createVNode(Tree, {
+        "showIcon": true,
+        "showLine": {
+          showLeafIcon: false
+        },
+        "blockNode": true,
+        "draggable": draggable.value ? {
+          icon: false
+        } : false,
+        "checkedKeys": props.checkedKeys,
+        "onCheck": handleCheckedKeys,
+        "multiple": true,
+        "checkable": true,
+        "icon": node => createVNode("i", {
+          "class": ['iconfont', node.isLeaf ? FieldIconMap[node.fieldType] || 'icon-zidingyi' : 'icon-file']
+        }, null),
+        "onSelect": (_, {
+          selectedNodes
+        }) => {
+          handleCheckedKeys(selectedNodes.map(node => node.key));
+        },
+        "treeData": filteredTreeData.value,
+        "onDrop": ({
+          node,
+          dragNode,
+          dropToGap,
+          dropPosition
+        }) => {
+          const dropPos = node.pos.split('-');
+          const dir = dropPosition - Number(dropPos[dropPos.length - 1]);
+          // console.log(node, dragNode, dropPosition, dropToGap);
+          // 拖动到上下
+          if (dropToGap) {
+            props.treeObj.moveTreeNode(dragNode.dataRef, node.dataRef, dir);
+          }
+        }
+      }, slots)])]);
+    };
+  }
+});
+
+export { TransferTree as default };

package/es/components/field-transfer/components/Transfer/TreeItem.d.ts

@@ -0,0 +1,17 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    node: {
+        type: PropType<IObject>;
+        required: true;
+    };
+    draggable: BooleanConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    node: {
+        type: PropType<IObject>;
+        required: true;
+    };
+    draggable: BooleanConstructor;
+}>> & Readonly<{}>, {
+    draggable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/components/field-transfer/components/Transfer/TreeItem.mjs

@@ -0,0 +1,41 @@
+import { defineComponent, computed, createVNode } from 'vue';
+import { Tooltip } from 'ant-design-vue';
+import '../../less/TreeItem.css';/* empty css                        */
+import { t } from '@gct-paas/core';
+
+const TreeItem = /* @__PURE__ */ defineComponent({
+  name: 'TreeItem',
+  props: {
+    node: {
+      type: Object,
+      required: true
+    },
+    draggable: Boolean
+  },
+  setup(props) {
+    const editing = computed(() => {
+      return props.node.isNew;
+    });
+    return () => {
+      return createVNode("div", {
+        "class": "tree-item-container"
+      }, [createVNode("div", {
+        "class": "tree-title"
+      }, [createVNode(Tooltip, {
+        "title": props.node.tooltip
+      }, {
+        default: () => [createVNode("span", null, [props.node.title || '-'])]
+      })]), !editing.value && props.draggable && !props.node?.disabled && !props.node?._preset && createVNode("div", {
+        "class": "operation-container"
+      }, [createVNode(Tooltip, {
+        "title": t('sys.component.fieldTransfer.move')
+      }, {
+        default: () => [createVNode("i", {
+          "class": ['iconfont', 'icon-drag']
+        }, null)]
+      })])]);
+    };
+  }
+});
+
+export { TreeItem as default };

package/es/components/field-transfer/components/field-transfer-modal.css

@@ -0,0 +1,5 @@
+.field-transfer-container[data-v-e48e5176] {
+  position: relative;
+  width: 100%;
+  height: 100%;
+}

package/es/components/field-transfer/components/field-transfer-modal.vue.d.ts

@@ -0,0 +1,43 @@
+import { FIELD_TYPE, CreateType } from '@gct-paas/core';
+export interface Prop {
+    /** 模型key */
+    modelKey: string;
+    /** 是否显示级联选择 */
+    isShowCascader?: boolean;
+    /** 弹框标题 */
+    modalTitle?: string;
+    /** 选中的字段数组 */
+    data?: IObject[];
+    /** 穿梭框标题集合 */
+    titles?: string[];
+    /** 包含的字段 */
+    containFieldType?: FIELD_TYPE[];
+    /** 包含的字段Key */
+    containFieldKey?: string[];
+    /** 禁用的字段 */
+    disabledFieldKey?: string[];
+    /** 排除的字段key */
+    excludeFieldKey?: string[];
+    /** 排除的字段 */
+    excludeFieldType?: FIELD_TYPE[];
+    /**包含的字段创建类型 */
+    containCreateType?: CreateType[];
+    /**自定义过滤函数 */
+    filterFieldByFunction?: (field: IObject) => boolean;
+    /** 最大选择个数 */
+    maxEnableCount?: number;
+    modalKey?: string;
+    /** 是否支持拖拽 */
+    draggable?: boolean;
+    /**
+     * 子表的关联主键字段的父模型字段
+     */
+    childParentModelKey?: string;
+    destroyCallback?: () => void;
+    saveCallback?: (params: IObject) => void;
+    promptMessage?: string;
+}
+declare const _default: import('vue').DefineComponent<Prop, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Prop> & Readonly<{}>, {
+    draggable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/components/field-transfer/components/field-transfer-modal.vue2.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from './field-transfer-modal.vue3.mjs';
+import './field-transfer-modal.css';/* empty css                          */
+import _export_sfc from '../../../_virtual/_plugin-vue_export-helper.mjs';
+
+const FieldTransferModal = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e48e5176"]]);
+
+export { FieldTransferModal as default };

package/es/components/field-transfer/components/field-transfer-modal.vue3.mjs

@@ -0,0 +1,230 @@
+import { defineComponent, computed, ref, onBeforeMount, watch, resolveComponent, openBlock, createBlock, unref, mergeProps, withCtx, createElementVNode, createVNode, createElementBlock, toDisplayString, createCommentVNode, toRaw } from 'vue';
+import { useModalInner, BasicModal } from '@gct-paas/core-web';
+import { isEmpty, pick } from 'lodash-es';
+import '../../../hooks/design-view/design-state.mjs';
+import { SCOPEINFO, t } from '@gct-paas/core';
+import '../../../hooks/design-view/layout/useScope.mjs';
+import '../../../hooks/design-view/global/useGlobal.mjs';
+import '../../../schema/modal/modal.mjs';
+import '../../../schema/common-config/common-style.mjs';
+import '../../../schema/common-config/display-editor-config.mjs';
+import '../../../schema/common-config/common-field-editor-config.mjs';
+import '../../../schema/common-config/base-button-config.mjs';
+import '../../../schema/common-config/permission-editor-config.mjs';
+import '../../../schema/common-config/button-editor-config.mjs';
+import '../../../schema/common-config/formItem-editor-config.mjs';
+import '@gct-paas/schema';
+import '@vueuse/core';
+import '../../../hooks/develop/useCacheHistory.mjs';
+import '../../user-occupy/user-occupy.css';import '../../user-occupy/user-lock.css';import './field-transfer-modal.css';import '../../field-cascader/src/FieldCascader.css';import '../../design-view-layout/design-view-layout.css';import '../../modal-name-editor/modal-name-editor.css';import '../../design-step-check/design-step-check.css';import '../../design-save-tip/design-save-tip.css';import '../../mobile-container/mobile-container.css';import '../../design-icon-button/design-icon-button.css';import '../../editor/style/font-editor/align-group.css';import '../../editor/style/font-editor/font-style-group.css';import '../../editor/style/position-editor/position-editor.css';import '../../editor/style/spacing-editor/spacing-editor.css';import '../../editor/style/border-editor/border-editor.css';import '../../editor/style/border-editor/border-radius.css';import '../../editor/style/border-editor/border-box.css';/* empty css                                               */
+/* empty css                                                  */
+/* empty css                                                  */
+/* empty css                                                    */
+import '../../icon/upleft-icon.vue.mjs';
+import '../../icon/downleft-icon.vue.mjs';
+import '../../icon/downright-icon.vue.mjs';
+import '../../icon/upright-icon.vue.mjs';
+/* empty css                                                      */
+import '@ant-design/icons-vue';
+import '../../editor/style/font-editor/util.mjs';
+/* empty css                                                   */
+/* empty css                                              */
+/* empty css                                                */
+import 'dayjs';
+/* empty css                                            */
+/* empty css                                          */
+/* empty css                                              */
+/* empty css                                              */
+/* empty css                                                */
+import '../../field-cascader/src/hooks.mjs';
+/* empty css                                           */
+import FieldCascader from './Cascader/FieldCascader.mjs';
+import FieldTransfer from './Transfer/FieldTransfer.mjs';
+/* empty css                          */
+import '../../user-occupy/useUserOccupy.mjs';
+/* empty css                                */
+/* empty css                                  */
+import '../../../hooks/design-view/widget/useSelectedWidget.mjs';
+import 'ant-design-vue';
+import '../../../utils/begin-drag/begin-drag.mjs';
+import 'axios';
+import '../../../utils/design-view/index.mjs';
+import '../../../utils/field-attrs/basicAttrs.mjs';
+import '../../../utils/field-filter/index.mjs';
+import '../../../utils/find-deep-types/find-deep-types.mjs';
+import '../../../hooks/design-view/widget/useWidget.mjs';
+import '../../../hooks/design-view/page/usePage.mjs';
+import '../../../hooks/design-view/page/usePageOccupy.mjs';
+import '../../../hooks/design-view/layout/useToolkit.mjs';
+import { useModelField } from '../../../hooks/use-model-field/use-model-field.mjs';
+import 'qx-util';
+
+const _hoisted_1 = { class: "field-transfer-container" };
+const _hoisted_2 = {
+  key: 0,
+  class: "h26px leading-26px bg-[#3168EC]/[0.1] pl-10px mb10px"
+};
+const _hoisted_3 = { class: "text-[#666] ml6px" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "field-transfer-modal",
+  props: {
+    modelKey: {},
+    isShowCascader: { type: Boolean },
+    modalTitle: {},
+    data: {},
+    titles: {},
+    containFieldType: {},
+    containFieldKey: {},
+    disabledFieldKey: {},
+    excludeFieldKey: {},
+    excludeFieldType: {},
+    containCreateType: {},
+    filterFieldByFunction: {},
+    maxEnableCount: {},
+    modalKey: {},
+    draggable: { type: Boolean, default: true },
+    childParentModelKey: {},
+    destroyCallback: {},
+    saveCallback: {},
+    promptMessage: {}
+  },
+  setup(__props) {
+    const [registerInner, { closeModal }] = useModalInner();
+    const props = __props;
+    const getContainer = () => document.querySelector(`#${props.modalKey}`);
+    const {
+      loadObjInfo,
+      modelFieldMap,
+      getModelFieldInfo,
+      clearSelectInfo,
+      clearObjInfo,
+      selectObj
+    } = useModelField(SCOPEINFO.FIELD_LIST);
+    const _selectObj = computed(() => {
+      return isLoad.value ? selectObj : {};
+    });
+    const objFieldList = ref([]);
+    const isLoad = ref(false);
+    onBeforeMount(async () => {
+      objFieldList.value = [];
+      clearSelectInfo();
+      clearObjInfo();
+      if (props.modelKey) {
+        isLoad.value = await loadObjInfo(props.modelKey, {
+          isShowCascader: props.isShowCascader,
+          childParentModelKey: props.childParentModelKey
+        });
+      }
+    });
+    watch(
+      [() => props.data, () => modelFieldMap.value, isLoad],
+      () => {
+        if (!isEmpty(modelFieldMap.value)) {
+          objFieldList.value = props.data?.map((item) => {
+            const obj = pick(item, [
+              "isFieldModel",
+              "modelKey",
+              "fieldCodeChain",
+              "key",
+              "field",
+              "disabled"
+            ]);
+            const fieldInfo = getModelFieldInfo(
+              obj.modelKey,
+              obj.field || obj.key
+            );
+            if (fieldInfo) {
+              return {
+                ...fieldInfo,
+                isFieldModel: obj.isFieldModel || false,
+                disabled: obj.disabled || false,
+                fieldCodeChain: obj.fieldCodeChain ?? JSON.stringify({ modelKey: fieldInfo.modelKey })
+              };
+            }
+          }).filter((i) => i) ?? [];
+        }
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    const setObjFieldList = (list) => {
+      objFieldList.value = list;
+    };
+    const handleShow = async (visible) => {
+    };
+    const handleClose = () => {
+      objFieldList.value = [];
+      clearSelectInfo();
+      clearObjInfo();
+      isLoad.value = false;
+      if (props.destroyCallback && typeof props.destroyCallback === "function") {
+        props.destroyCallback();
+      }
+    };
+    const handleOk = async () => {
+      if (props.saveCallback && typeof props.saveCallback === "function") {
+        const params = {
+          objFieldList: toRaw(objFieldList.value)
+        };
+        props.saveCallback(params);
+      }
+      closeModal();
+    };
+    return (_ctx, _cache) => {
+      const _component_a_spin = resolveComponent("a-spin");
+      return openBlock(), createBlock(unref(BasicModal), mergeProps(_ctx.$attrs, {
+        "min-height": 40,
+        title: __props.modalTitle || unref(t)("sys.component.fieldTransfer.defaultModalTitle"),
+        centered: "",
+        "can-fullscreen": false,
+        "mask-closable": false,
+        "after-close": handleClose,
+        "get-container": getContainer,
+        onRegister: unref(registerInner),
+        onOk: handleOk,
+        onVisibleChange: handleShow
+      }), {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            createVNode(_component_a_spin, {
+              spinning: !isLoad.value
+            }, {
+              default: withCtx(() => [
+                __props.promptMessage ? (openBlock(), createElementBlock("div", _hoisted_2, [
+                  _cache[0] || (_cache[0] = createElementVNode("i", { class: "iconfont icon-guanyu text-[#3168EC]" }, null, -1)),
+                  createElementVNode("span", _hoisted_3, toDisplayString(__props.promptMessage), 1)
+                ])) : createCommentVNode("", true),
+                createVNode(unref(FieldCascader), {
+                  class: "mb-8px",
+                  "is-show-cascader": __props.isShowCascader,
+                  scope: unref(SCOPEINFO).FIELD_LIST
+                }, null, 8, ["is-show-cascader", "scope"]),
+                createVNode(unref(FieldTransfer), {
+                  titles: __props.titles,
+                  "max-enable-count": __props.maxEnableCount,
+                  draggable: __props.draggable,
+                  "disabled-field-key": __props.disabledFieldKey,
+                  "contain-field-key": __props.containFieldKey,
+                  "contain-field-type": __props.containFieldType,
+                  "exclude-field-key": __props.excludeFieldKey,
+                  "contain-create-type": __props.containCreateType,
+                  "exclude-field-type": __props.excludeFieldType,
+                  "filter-field-by-function": __props.filterFieldByFunction,
+                  "obj-fields": _selectObj.value,
+                  value: objFieldList.value,
+                  "on-change": setObjFieldList
+                }, null, 8, ["titles", "max-enable-count", "draggable", "disabled-field-key", "contain-field-key", "contain-field-type", "exclude-field-key", "contain-create-type", "exclude-field-type", "filter-field-by-function", "obj-fields", "value"])
+              ]),
+              _: 1
+            }, 8, ["spinning"])
+          ])
+        ]),
+        _: 1
+      }, 16, ["title", "onRegister"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/components/field-transfer/components/modal-wrapper.vue.d.ts

@@ -0,0 +1,19 @@
+interface IProps {
+    /** 模型key */
+    modelKey: string;
+    /** 模态框标题 */
+    modalTitle?: string;
+    /** 是否显示级联选择 */
+    isShowCascader?: boolean;
+    /** 选中的字段信息 */
+    data: IObject[];
+    /**
+     * 子表的关联主键字段的父模型字段
+     */
+    childParentModelKey?: string;
+    saveCallback?: (params: IObject) => void;
+}
+declare const _default: import('vue').DefineComponent<IProps, {
+    open: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/components/field-transfer/components/modal-wrapper.vue.mjs

@@ -0,0 +1,29 @@
+import { defineComponent, openBlock, createBlock, mergeProps, unref } from 'vue';
+import FieldTransferModal from './field-transfer-modal.vue2.mjs';
+import { useModal } from '@gct-paas/core-web';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "modal-wrapper",
+  props: {
+    modelKey: {},
+    modalTitle: {},
+    isShowCascader: { type: Boolean },
+    data: {},
+    childParentModelKey: {},
+    saveCallback: { type: Function }
+  },
+  setup(__props, { expose: __expose }) {
+    const [register, { openModal }] = useModal();
+    const open = () => {
+      openModal();
+    };
+    __expose({
+      open
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(FieldTransferModal, mergeProps(_ctx.$props, { onRegister: unref(register) }), null, 16, ["onRegister"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/components/field-transfer/components/modal-wrapper.vue2.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './modal-wrapper.vue.mjs';
+
+
+
+export { _sfc_main as default };

package/es/components/field-transfer/hooks/useTreeData.d.ts

@@ -0,0 +1,139 @@
+import { ColumnItem, FieldItem, TreeNodeGroup, TreeNode, ColumnsChange } from '../types/index.d';
+export declare const useTreeData: (useMultiLevelTHead: boolean, isResetData?: boolean, draggable?: boolean, maxEnableCount?: number, onColumnsChange?: ColumnsChange) => {
+    data: import('vue').ComputedRef<({
+        type: "group";
+        width?: number | undefined;
+        children: (/*elided*/ any | {
+            type: "field";
+            field: {
+                id: string;
+                modelKey: string;
+                displayLabel: string;
+                type: FIELD_TYPE;
+                disabled: boolean;
+                hidden?: boolean | undefined;
+            };
+            modelKey: string;
+            width?: number | undefined;
+            fieldType: FIELD_TYPE;
+            key: string;
+            title: string;
+            level: number;
+            parent: /*elided*/ any;
+            disableCheckbox?: boolean | undefined;
+            isLeaf?: boolean | undefined;
+            isNew?: boolean | undefined;
+        })[];
+        key: string;
+        title: string;
+        level: number;
+        parent: /*elided*/ any;
+        disableCheckbox?: boolean | undefined;
+        isLeaf?: boolean | undefined;
+        isNew?: boolean | undefined;
+    } | {
+        type: "field";
+        field: {
+            id: string;
+            modelKey: string;
+            displayLabel: string;
+            type: FIELD_TYPE;
+            disabled: boolean;
+            hidden?: boolean | undefined;
+        };
+        modelKey: string;
+        width?: number | undefined;
+        fieldType: FIELD_TYPE;
+        key: string;
+        title: string;
+        level: number;
+        parent: {
+            type: "group";
+            width?: number | undefined;
+            children: (/*elided*/ any | /*elided*/ any)[];
+            key: string;
+            title: string;
+            level: number;
+            parent: /*elided*/ any;
+            disableCheckbox?: boolean | undefined;
+            isLeaf?: boolean | undefined;
+            isNew?: boolean | undefined;
+        };
+        disableCheckbox?: boolean | undefined;
+        isLeaf?: boolean | undefined;
+        isNew?: boolean | undefined;
+    })[]>;
+    root: {
+        type: "group";
+        width?: number | undefined;
+        children: (/*elided*/ any | {
+            type: "field";
+            field: {
+                id: string;
+                modelKey: string;
+                displayLabel: string;
+                type: FIELD_TYPE;
+                disabled: boolean;
+                hidden?: boolean | undefined;
+            };
+            modelKey: string;
+            width?: number | undefined;
+            fieldType: FIELD_TYPE;
+            key: string;
+            title: string;
+            level: number;
+            parent: /*elided*/ any;
+            disableCheckbox?: boolean | undefined;
+            isLeaf?: boolean | undefined;
+            isNew?: boolean | undefined;
+        })[];
+        key: string;
+        title: string;
+        level: number;
+        parent: /*elided*/ any;
+        disableCheckbox?: boolean | undefined;
+        isLeaf?: boolean | undefined;
+        isNew?: boolean | undefined;
+    };
+    leafKeys: import('vue').Ref<string[], string[]>;
+    multiple: import('vue').ComputedRef<boolean>;
+    draggable: boolean | undefined;
+    remainCount: import('vue').ComputedRef<number>;
+    addTreeNodes(nodes: Omit<TreeNode, "parent">[], parent: TreeNodeGroup): void;
+    removeTreeNodesByKeys(keys: string[]): void;
+    moveTreeNode(source: TreeNode, target: TreeNode, direction: number, asChildren?: boolean): void;
+    getContainerNode: () => {
+        type: "group";
+        width?: number | undefined;
+        children: (/*elided*/ any | {
+            type: "field";
+            field: {
+                id: string;
+                modelKey: string;
+                displayLabel: string;
+                type: FIELD_TYPE;
+                disabled: boolean;
+                hidden?: boolean | undefined;
+            };
+            modelKey: string;
+            width?: number | undefined;
+            fieldType: FIELD_TYPE;
+            key: string;
+            title: string;
+            level: number;
+            parent: /*elided*/ any;
+            disableCheckbox?: boolean | undefined;
+            isLeaf?: boolean | undefined;
+            isNew?: boolean | undefined;
+        })[];
+        key: string;
+        title: string;
+        level: number;
+        parent: /*elided*/ any;
+        disableCheckbox?: boolean | undefined;
+        isLeaf?: boolean | undefined;
+        isNew?: boolean | undefined;
+    };
+    onChangeTree: (columnsData: ColumnItem[], fields: FieldItem[]) => void;
+};
+export type TreeProps = ReturnType<typeof useTreeData>;