qidian-vue-ui 2.0.15 → 2.0.17

package/dist/components/dict/select/index.vue.mjs

@@ -1,4 +1,4 @@
-import { defineComponent, mergeDefaults, computed, toRef, createBlock, openBlock, unref, mergeProps, isRef, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps, watch } from "vue";
+import { defineComponent, mergeDefaults, computed, toRef, ref, onMounted, onActivated, onDeactivated, createBlock, openBlock, unref, mergeProps, isRef, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps, watch } from "vue";
 import { useVModels } from "../../../node_modules/.pnpm/@vueuse_core@14.2.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.mjs";
 import { isEmpty } from "qidian-shared";
 import { Select } from "tdesign-vue-next";
@@ -153,13 +153,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const dictType = toRef(props, "dictType");
     let hasAutoSelected = false;
     let unWatchAutoSelected;
+    const autofocus = ref(false);
+    let autoOpenedOnce = false;
     const reProps = computed(() => {
       const {
         convStr,
         strict,
         modelValue: modelValue2,
         inputValue: inputValue2,
-        popupVisible: popupVisible2,
+        popupVisible: inPopupVisible,
         valueLabel: valueLabel2,
         dictType: dictType2,
         loading,
@@ -167,6 +169,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         onDefaultSelectFirst,
         dedupe,
         options,
+        autofocus: autofocus2,
+        onFocus,
         onChange,
         ...selectOptions
       } = props;
@@ -181,7 +185,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           reValueLabel.value = context.option?.[labelKey] || "";
         }
       };
+      const reOnFocus = (context) => {
+        onFocus?.(context);
+        if (autofocus2 && !autoOpenedOnce && !popupVisible.value) {
+          autoOpenedOnce = true;
+          popupVisible.value = true;
+        }
+      };
       return {
+        autofocus: autofocus2,
         convStr,
         strict,
         dictType: dictType2,
@@ -192,12 +204,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         options,
         selectOptions: {
           ...selectOptions,
+          onFocus: reOnFocus,
           onChange: reOnChange
         },
         models: {
           modelValue: modelValue2,
           inputValue: inputValue2,
-          popupVisible: popupVisible2
+          popupVisible: inPopupVisible
         }
       };
     });
@@ -239,6 +252,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
     }
     setAutoSelectedWatch();
+    onMounted(() => {
+      autofocus.value = reProps.value.autofocus;
+    });
+    onActivated(() => {
+      autofocus.value = reProps.value.autofocus;
+    });
+    onDeactivated(() => {
+      autofocus.value = false;
+    });
     return (_ctx, _cache) => {
       return openBlock(), createBlock(unref(Select), mergeProps({
         modelValue: reModelValue.value,
@@ -246,7 +268,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         "input-value": unref(inputValue),
         "onUpdate:inputValue": _cache[1] || (_cache[1] = ($event) => isRef(inputValue) ? inputValue.value = $event : null),
         "popup-visible": unref(popupVisible),
-        "onUpdate:popupVisible": _cache[2] || (_cache[2] = ($event) => isRef(popupVisible) ? popupVisible.value = $event : null)
+        "onUpdate:popupVisible": _cache[2] || (_cache[2] = ($event) => isRef(popupVisible) ? popupVisible.value = $event : null),
+        autofocus: autofocus.value
       }, reProps.value.selectOptions, {
         options: reDictOptions.value,
         loading: unref(dictLoading) || reProps.value.loading
@@ -259,7 +282,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             ])
           };
         })
-      ]), 1040, ["modelValue", "input-value", "popup-visible", "options", "loading"]);
+      ]), 1040, ["modelValue", "input-value", "popup-visible", "autofocus", "options", "loading"]);
     };
   }
 });

package/dist/components/index.d.ts

@@ -22,5 +22,6 @@ export * from './service-dialog-table-select';
 export * from './service-dialog-tabs-table-select';
 export * from './service-popup-table-select';
 export * from './service-select';
+export * from './service-tree-select';
 export * from './steps';
 export * from './upload';

package/dist/components/service-dialog-table-select/index.css

@@ -1,31 +1,31 @@
-.qd-dialog-table-select[data-v-0fe40893] {
+.qd-dialog-table-select[data-v-3992bc28] {
   width: 100%;
 }
-.qd-dialog-table-select__trigger[data-v-0fe40893] {
+.qd-dialog-table-select__trigger[data-v-3992bc28] {
   width: 100%;
 }
-.qd-dialog-table-select__trigger[data-v-0fe40893]:not(.qd-dialog-table-select__trigger--readonly):not(.qd-dialog-table-select__trigger--disabled) {
+.qd-dialog-table-select__trigger[data-v-3992bc28]:not(.qd-dialog-table-select__trigger--readonly):not(.qd-dialog-table-select__trigger--disabled) {
   cursor: pointer;
 }
-.qd-dialog-table-select__input-trigger[data-v-0fe40893] {
+.qd-dialog-table-select__input-trigger[data-v-3992bc28] {
   border-top-left-radius: 0;
   border-bottom-left-radius: 0;
 }
-.qd-dialog-table-select__table[data-v-0fe40893] .qd-crud-search > .t-loading__parent > .t-card__body,
-.qd-dialog-table-select__table[data-v-0fe40893] .qd-crud-table__body > .t-loading__parent > .t-card__body {
+.qd-dialog-table-select__table[data-v-3992bc28] .qd-crud-search > .t-loading__parent > .t-card__body,
+.qd-dialog-table-select__table[data-v-3992bc28] .qd-crud-table__body > .t-loading__parent > .t-card__body {
   padding: 0 !important;
 }
-.qd-dialog-table-select__table[data-v-0fe40893] .qd-crud-table__toolbar {
+.qd-dialog-table-select__table[data-v-3992bc28] .qd-crud-table__toolbar {
   display: none;
 }
-.qd-dialog-table-select__table[data-v-0fe40893] .qd-service-table {
+.qd-dialog-table-select__table[data-v-3992bc28] .qd-service-table {
   margin-top: 0;
 }
-.qd-dialog-table-select__table-add[data-v-0fe40893] {
+.qd-dialog-table-select__table-add[data-v-3992bc28] {
   margin-top: var(--td-comp-margin-m);
   display: flex;
 }
-.qd-dialog-table-select__table-add .t-input__wrap[data-v-0fe40893] {
+.qd-dialog-table-select__table-add .t-input__wrap[data-v-3992bc28] {
   flex: 1 1 0;
   overflow: hidden;
   margin-right: var(--td-comp-margin-m);

package/dist/components/service-dialog-table-select/index.vue.d.ts

@@ -23,6 +23,13 @@ declare const _default: <D extends TableRowData = TableRowData, R = unknown, P =
         default?: (props: {
             selectedRows: import("@vue/reactivity").UnwrapRefSimple<D>[];
         }) => any;
+    } & {
+        'dialog-footer'?: (props: {
+            cancel: (event: MouseEvent) => void;
+            confirm: () => Promise<boolean | void>;
+            confirmLoading: boolean;
+            selectedOptions: import("@vue/reactivity").UnwrapRefSimple<D>[];
+        }) => any;
     } & {
         'dialog-footer-extend'?: (props: {}) => any;
     } & {

package/dist/components/service-dialog-table-select/index.vue.mjs

@@ -2,7 +2,7 @@ import './index.css'
 import _sfc_main from "./index.vue2.mjs";
 /* empty css            */
 import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-0fe40893"]]);
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3992bc28"]]);
 export {
   index as default
 };

package/dist/components/service-dialog-table-select/index.vue2.mjs

@@ -357,7 +357,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const confirmLoad = ref(false);
     const selectedRowKeys = ref([]);
     const selectedRows = ref([]);
-    let latestSelectedRows = [];
+    const latestSelectedRows = ref([]);
     let lastRowKey;
     const addCustom = reactive({
       visible: false,
@@ -562,15 +562,16 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         return change;
       },
       onSingleClick: (rowKeys, options) => {
-        latestSelectedRows = cleanEmptyChildren(options.selectedRowData, reProps.value.tableOptions.tree?.childrenKey);
+        latestSelectedRows.value = cleanEmptyChildren(options.selectedRowData, reProps.value.tableOptions.tree?.childrenKey);
       },
       onDoubleClick: (rowKeys, options) => {
-        latestSelectedRows = cleanEmptyChildren(options.selectedRowData, reProps.value.tableOptions.tree?.childrenKey);
+        latestSelectedRows.value = cleanEmptyChildren(options.selectedRowData, reProps.value.tableOptions.tree?.childrenKey);
         handleConfirm();
       }
     });
     async function handleConfirm(done) {
-      selectedRows.value = latestSelectedRows;
+      const latestRows = latestSelectedRows.value;
+      selectedRows.value = latestRows;
       const {
         selectOptions,
         keys
@@ -578,17 +579,17 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       const valueKey = keys.value;
       const labelKey = keys.label;
       if (selectOptions.valueType === "value") {
-        modelValue.value = selectOptions.multiple ? latestSelectedRows.map((item) => get(item, valueKey)) : get(latestSelectedRows[0], valueKey);
+        modelValue.value = selectOptions.multiple ? latestRows.map((item) => get(item, valueKey)) : get(latestRows[0], valueKey);
       } else {
-        const rows = latestSelectedRows.map((item) => ({
+        const rows = latestRows.map((item) => ({
           [valueKey]: get(item, valueKey),
           [labelKey]: get(item, labelKey)
         }));
         modelValue.value = selectOptions.multiple ? rows : rows[0];
       }
       const eventParams = [modelValue.value, {
-        option: latestSelectedRows[latestSelectedRows.length - 1],
-        selectedOptions: latestSelectedRows,
+        option: latestRows[latestRows.length - 1],
+        selectedOptions: latestRows,
         trigger: "check"
       }];
       reProps.value.onChange?.(...eventParams);
@@ -609,6 +610,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
       return onConfirm(...eventParams, done);
     }
+    function handleFooterCancel(event) {
+      visible.value = false;
+      reProps.value.dialogOptions.onCancel?.({
+        e: event
+      });
+    }
     function openDialog() {
       const {
         selectOptions
@@ -664,22 +671,25 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       });
     }
     function handleBeforeOpen() {
-      const {
-        keys
-      } = reProps.value;
-      const valueKey = keys.value;
-      if (identifyType(modelValue.value) === "array") {
-        selectedRowKeys.value = modelValue.value.map((item) => {
-          if (identifyType(item) === "object") {
-            return get(item, valueKey);
-          }
-          return item;
-        });
-      } else if (identifyType(modelValue.value) === "object") {
-        selectedRowKeys.value = [get(modelValue.value, valueKey)];
-      } else {
-        selectedRowKeys.value = isEmpty(modelValue.value) ? [] : [modelValue.value];
-      }
+      syncSelectionFromModel();
+    }
+    function getModelValueKeys() {
+      if (isEmpty(modelValue.value)) return [];
+      const valueKey = reProps.value.keys.value;
+      const values = identifyType(modelValue.value) === "array" ? modelValue.value : [modelValue.value];
+      return values.map((item) => identifyType(item) === "object" ? get(item, valueKey) : item).filter((value) => ["string", "number"].includes(typeof value));
+    }
+    function syncSelectionFromModel() {
+      const keys = getModelValueKeys();
+      const valueKey = reProps.value.keys.value;
+      const rowMap = /* @__PURE__ */ new Map();
+      const rows = [...reProps.value.fillOptions ?? [], ...selectedRows.value, ...data.value ?? []];
+      rows.forEach((row) => {
+        const key = get(row, valueKey);
+        if (typeof key === "string" || typeof key === "number") rowMap.set(key, row);
+      });
+      selectedRowKeys.value = keys;
+      latestSelectedRows.value = keys.map((key) => rowMap.get(key)).filter((row) => !!row);
     }
     function handleClosed() {
       if (addCustom.visible) cancelAddCustom();
@@ -689,6 +699,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         selectedRowKeys.value = [];
       }
     }
+    watch(modelValue, syncSelectionFromModel, {
+      deep: true
+    });
     watch(markedFillOptions, (fillOpts) => {
       const currentSelected = (selectedRows.value || []).filter((opt) => !opt[QD_FILL_OPTION_MARK]);
       if (!fillOpts?.length) {
@@ -825,10 +838,19 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           };
         })]), 1040, ["search-data", "data", "selected-row-keys", "active-row-keys", "column-controller-visible", "expanded-rowKeys", "filter-value", "sort", "expanded-tree-nodes", "onSelectChange"])]),
         _: 2
-      }, [_ctx.$slots["dialog-footer-extend"] ? {
+      }, [_ctx.$slots["dialog-footer"] ? {
+        name: "footer",
+        fn: withCtx(() => [renderSlot(_ctx.$slots, "dialog-footer", {
+          cancel: handleFooterCancel,
+          confirm: () => handleConfirm(),
+          confirmLoading: confirmLoad.value,
+          selectedOptions: latestSelectedRows.value
+        }, void 0, true)]),
+        key: "0"
+      } : void 0, _ctx.$slots["dialog-footer-extend"] ? {
         name: "footer-extend",
         fn: withCtx(() => [renderSlot(_ctx.$slots, "dialog-footer-extend", {}, void 0, true)]),
-        key: "0"
+        key: "1"
       } : void 0]), 1040, ["visible", "confirm-loading"])], 64);
     };
   }

package/dist/components/service-dialog-tabs-table-select/index.css

@@ -1,37 +1,37 @@
-.qd-dialog-tabs-table-select[data-v-f8e4cc1d] {
+.qd-dialog-tabs-table-select[data-v-1461ff61] {
   width: 100%;
 }
-.qd-dialog-tabs-table-select__trigger[data-v-f8e4cc1d] {
+.qd-dialog-tabs-table-select__trigger[data-v-1461ff61] {
   width: 100%;
 }
-.qd-dialog-tabs-table-select__trigger[data-v-f8e4cc1d]:not(.qd-dialog-tabs-table-select__trigger--readonly):not(.qd-dialog-tabs-table-select__trigger--disabled) {
+.qd-dialog-tabs-table-select__trigger[data-v-1461ff61]:not(.qd-dialog-tabs-table-select__trigger--readonly):not(.qd-dialog-tabs-table-select__trigger--disabled) {
   cursor: pointer;
 }
-.qd-dialog-tabs-table-select__input-trigger[data-v-f8e4cc1d] {
+.qd-dialog-tabs-table-select__input-trigger[data-v-1461ff61] {
   border-top-left-radius: 0;
   border-bottom-left-radius: 0;
 }
-.qd-dialog-tabs-table-select__table[data-v-f8e4cc1d] .qd-crud-search > .t-loading__parent > .t-card__body {
+.qd-dialog-tabs-table-select__table[data-v-1461ff61] .qd-crud-search > .t-loading__parent > .t-card__body {
   padding-left: 0 !important;
   padding-right: 0 !important;
   padding-bottom: 0 !important;
 }
-.qd-dialog-tabs-table-select__table[data-v-f8e4cc1d] .qd-crud-table__body > .t-loading__parent > .t-card__body {
+.qd-dialog-tabs-table-select__table[data-v-1461ff61] .qd-crud-table__body > .t-loading__parent > .t-card__body {
   padding-left: 0 !important;
   padding-right: 0 !important;
   padding-bottom: 0 !important;
 }
-.qd-dialog-tabs-table-select__table[data-v-f8e4cc1d] .qd-crud-table__toolbar {
+.qd-dialog-tabs-table-select__table[data-v-1461ff61] .qd-crud-table__toolbar {
   display: none;
 }
-.qd-dialog-tabs-table-select__table[data-v-f8e4cc1d] .qd-service-table {
+.qd-dialog-tabs-table-select__table[data-v-1461ff61] .qd-service-table {
   margin-top: 0;
 }
-.qd-dialog-tabs-table-select__table-add[data-v-f8e4cc1d] {
+.qd-dialog-tabs-table-select__table-add[data-v-1461ff61] {
   margin-top: var(--td-comp-margin-m);
   display: flex;
 }
-.qd-dialog-tabs-table-select__table-add .t-input__wrap[data-v-f8e4cc1d] {
+.qd-dialog-tabs-table-select__table-add .t-input__wrap[data-v-1461ff61] {
   flex: 1 1 0;
   overflow: hidden;
   margin-right: var(--td-comp-margin-m);

package/dist/components/service-dialog-tabs-table-select/index.vue.d.ts

@@ -18,6 +18,14 @@ declare const _default: <D extends TableRowData = TableRowData, R = unknown, P =
         default?: (props: {
             selectedRows: import("@vue/reactivity").UnwrapRefSimple<D>[];
         }) => any;
+    } & {
+        'dialog-footer'?: (props: {
+            cancel: (event: MouseEvent) => void;
+            confirm: () => Promise<boolean | void>;
+            confirmLoading: boolean;
+            selectedOptions: import("@vue/reactivity").UnwrapRefSimple<D>[];
+            activeTab: import("tdesign-vue-next").TabValue | undefined;
+        }) => any;
     } & {
         'dialog-footer-extend'?: (props: {
             activeTab: import("tdesign-vue-next").TabValue | undefined;

package/dist/components/service-dialog-tabs-table-select/index.vue.mjs

@@ -2,7 +2,7 @@ import './index.css'
 import _sfc_main from "./index.vue2.mjs";
 /* empty css            */
 import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-f8e4cc1d"]]);
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1461ff61"]]);
 export {
   index as default
 };

package/dist/components/service-dialog-tabs-table-select/index.vue2.mjs

@@ -1,5 +1,5 @@
 import './index.css'
-import { defineComponent, mergeDefaults, ref, useTemplateRef, computed, shallowRef, reactive, h, watch, createElementBlock, openBlock, Fragment, createElementVNode, createVNode, mergeProps, unref, renderSlot, createBlock, withCtx, renderList, createTextVNode, toDisplayString, isRef, createSlots, normalizeProps, guardReactiveProps, nextTick } from "vue";
+import { defineComponent, mergeDefaults, ref, useTemplateRef, computed, reactive, h, watch, createElementBlock, openBlock, Fragment, createElementVNode, createVNode, mergeProps, unref, renderSlot, createBlock, withCtx, renderList, createTextVNode, toDisplayString, isRef, createSlots, normalizeProps, guardReactiveProps, nextTick } from "vue";
 import { useVModels } from "../../node_modules/.pnpm/@vueuse_core@14.2.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.mjs";
 import { useDoubleClick, isEmpty, identifyType, suspectedWrapperPromise, createExposeProxy, extractSlotsWithPrefix, hasOwn } from "qidian-shared";
 import { AddIcon, SearchIcon } from "tdesign-icons-vue-next";
@@ -468,6 +468,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       await nextTick();
       return handleCommonConfirm(done);
     }
+    function handleFooterCancel(event) {
+      visible.value = false;
+      reProps.value.dialogOptions.onCancel?.({
+        e: event
+      });
+    }
     const handleTabsSelectChange = useDoubleClick({
       shouldReset: (tab, rowKeys, options) => {
         const change = lastRowKey.value !== options.currentRowKey;
@@ -511,7 +517,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       const confirmLoad2 = ref(false);
       const selectedRowKeys2 = ref([]);
       const selectedRows2 = ref([]);
-      const latestSelectedRows2 = shallowRef([]);
+      const latestSelectedRows2 = ref([]);
       const lastRowKey2 = ref(void 0);
       const addCustom2 = reactive({
         visible: false,
@@ -734,7 +740,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         }
       });
       async function handleConfirm2(done) {
-        selectedRows2.value = latestSelectedRows2.value;
+        const latestRows = latestSelectedRows2.value;
+        selectedRows2.value = latestRows;
         const {
           selectOptions,
           keys
@@ -742,17 +749,17 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         const valueKey = keys.value;
         const labelKey = keys.label;
         if (selectOptions.valueType === "value") {
-          modelValue2.value = selectOptions.multiple ? latestSelectedRows2.value.map((item) => get(item, valueKey)) : get(latestSelectedRows2.value[0], valueKey);
+          modelValue2.value = selectOptions.multiple ? latestRows.map((item) => get(item, valueKey)) : get(latestRows[0], valueKey);
         } else {
-          const rows = latestSelectedRows2.value.map((item) => ({
+          const rows = latestRows.map((item) => ({
             [valueKey]: get(item, valueKey),
             [labelKey]: get(item, labelKey)
           }));
           modelValue2.value = selectOptions.multiple ? rows : rows[0];
         }
         const eventParams = [modelValue2.value, {
-          option: latestSelectedRows2.value[latestSelectedRows2.value.length - 1],
-          selectedOptions: latestSelectedRows2.value,
+          option: latestRows[latestRows.length - 1],
+          selectedOptions: latestRows,
           trigger: "check"
         }];
         reProps2.value.onChange?.(...eventParams);
@@ -1007,12 +1014,22 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           };
         })]), 1040, ["active-tab", "search-data", "tabs", "shared-search", "sync-service-key"])]),
         _: 2
-      }, [_ctx.$slots["dialog-footer-extend"] ? {
+      }, [_ctx.$slots["dialog-footer"] ? {
+        name: "footer",
+        fn: withCtx(() => [renderSlot(_ctx.$slots, "dialog-footer", {
+          cancel: handleFooterCancel,
+          confirm: () => handleConfirm(),
+          confirmLoading: unref(confirmLoad),
+          selectedOptions: unref(latestSelectedRows),
+          activeTab: currentActiveTab.value
+        }, void 0, true)]),
+        key: "0"
+      } : void 0, _ctx.$slots["dialog-footer-extend"] ? {
         name: "footer-extend",
         fn: withCtx(() => [renderSlot(_ctx.$slots, "dialog-footer-extend", {
           activeTab: currentActiveTab.value
         }, void 0, true)]),
-        key: "0"
+        key: "1"
       } : void 0]), 1040, ["visible", "confirm-loading"])], 64);
     };
   }

package/dist/components/service-tree-select/index.css

@@ -0,0 +1,5 @@
+
+.qd-service-tree-select__label--disabled {
+    color: var(--td-text-color-disabled);
+    cursor: not-allowed;
+}

package/dist/components/service-tree-select/index.d.ts

@@ -0,0 +1,2 @@
+export { default as QdServiceTreeSelect } from './index.vue';
+export type { QdServiceTreeSelectInstanceFunctions, QdServiceTreeSelectProps, QdServiceTreeSelectTreeOptions } from './types';

package/dist/components/service-tree-select/index.vue.d.ts

@@ -0,0 +1,25 @@
+import type { ServicePageParams } from 'qidian-shared';
+import type { TreeOptionData, TreeSelectValue } from 'tdesign-vue-next';
+import type { QdServiceTreeSelectInstanceFunctions, QdServiceTreeSelectProps } from './types';
+declare const _default: <D extends TreeOptionData = TreeOptionData, R = unknown, P = ServicePageParams, TP = P>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((args_0: TreeSelectValue | undefined) => any) | undefined;
+        readonly "onUpdate:data"?: ((args_0: D[] | undefined) => any) | undefined;
+        readonly "onUpdate:valueLabel"?: ((args_0: string | string[] | undefined) => any) | undefined;
+        readonly "onUpdate:inputValue"?: ((args_0: string | undefined) => any) | undefined;
+        readonly "onUpdate:popupVisible"?: ((args_0: boolean | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:data" | "onUpdate:valueLabel" | "onUpdate:inputValue" | "onUpdate:popupVisible"> & QdServiceTreeSelectProps<D, R, P, TP> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<QdServiceTreeSelectInstanceFunctions<D_1, R_1, P_1, TP_1>>): void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: any) => any) | undefined;
+        [x: number]: ((props: any) => any) | undefined;
+    };
+    emit: ((evt: "update:modelValue", args_0: TreeSelectValue | undefined) => void) & ((evt: "update:data", args_0: D[] | undefined) => void) & ((evt: "update:valueLabel", args_0: string | string[] | undefined) => void) & ((evt: "update:inputValue", args_0: string | undefined) => void) & ((evt: "update:popupVisible", args_0: boolean | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/service-tree-select/index.vue.mjs

@@ -0,0 +1,351 @@
+import './index.css'
+import { defineComponent, mergeDefaults, ref, computed, watch, onMounted, onActivated, onDeactivated, createBlock, openBlock, unref, mergeProps, isRef, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { useVModels } from "../../node_modules/.pnpm/@vueuse_core@14.2.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.mjs";
+import { useServiceLoadMore } from "qidian-shared";
+import { TreeSelect } from "tdesign-vue-next";
+import { qdServiceTreeSelectProps } from "./props.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "QdServiceTreeSelect"
+  },
+  __name: "index",
+  props: /* @__PURE__ */ mergeDefaults({
+    data: {},
+    autofocus: { type: Boolean },
+    onlyLeaf: { type: Boolean },
+    valueLabel: {},
+    tree: {},
+    transformParams: { type: Function },
+    transformRes: { type: Function },
+    autoWidth: { type: Boolean },
+    borderless: { type: Boolean },
+    clearable: { type: Boolean },
+    collapsedItems: {},
+    disabled: { type: Boolean },
+    empty: {},
+    filter: { type: Function },
+    filterable: { type: Boolean },
+    inputProps: {},
+    inputValue: {},
+    defaultInputValue: {},
+    keys: {},
+    loading: { type: Boolean },
+    loadingText: {},
+    max: {},
+    minCollapsedNum: {},
+    multiple: { type: Boolean },
+    panelBottomContent: {},
+    panelTopContent: {},
+    placeholder: {},
+    popupProps: {},
+    popupVisible: { type: Boolean },
+    prefixIcon: {},
+    readonly: { type: Boolean },
+    selectInputProps: {},
+    size: {},
+    suffix: {},
+    suffixIcon: {},
+    tagProps: {},
+    treeProps: {},
+    value: {},
+    defaultValue: {},
+    modelValue: {},
+    valueDisplay: {},
+    valueType: {},
+    onBlur: { type: Function },
+    onChange: { type: Function },
+    onClear: { type: Function },
+    onFocus: { type: Function },
+    onInputChange: { type: Function },
+    onPopupVisibleChange: { type: Function },
+    onRemove: { type: Function },
+    onSearch: { type: Function },
+    onBefore: { type: Function },
+    onAfter: { type: Function },
+    onSuccess: { type: Function },
+    onError: { type: Function },
+    service: { type: Function },
+    manual: { type: Boolean }
+  }, qdServiceTreeSelectProps),
+  emits: ["update:modelValue", "update:valueLabel", "update:inputValue", "update:popupVisible", "update:data"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { modelValue, valueLabel, inputValue, popupVisible, data } = useVModels(props, emit, {
+      passive: true
+    });
+    const nodeLabelMap = /* @__PURE__ */ new Map();
+    const loadingNodes = /* @__PURE__ */ new Map();
+    const autofocus = ref(false);
+    let autoOpenedOnce = false;
+    const reProps = computed(() => {
+      const {
+        service,
+        manual,
+        transformParams,
+        transformRes,
+        onBefore,
+        onAfter,
+        onSuccess,
+        onError,
+        tree,
+        onlyLeaf,
+        valueLabel: valueLabel2,
+        modelValue: modelValue2,
+        inputValue: inputValue2,
+        popupVisible: inPopupVisible,
+        data: data2,
+        loading: loading2,
+        filterable,
+        filter,
+        autofocus: inAutofocus,
+        inputProps,
+        treeProps,
+        onFocus,
+        onChange,
+        ...treeSelectOptions
+      } = props;
+      const reOnFocus = (context) => {
+        onFocus?.(context);
+        if (inAutofocus && !autoOpenedOnce && !popupVisible.value) {
+          autoOpenedOnce = true;
+          popupVisible.value = true;
+        }
+      };
+      const reOnChange = (value, context) => {
+        onChange?.(value, context);
+        syncValueLabel(value, context);
+      };
+      return {
+        externalLoading: loading2,
+        tree,
+        onlyLeaf,
+        treeSelectOptions: {
+          ...treeSelectOptions,
+          filterable,
+          filter: filter || (filterable && onlyLeaf ? filterOnlyLeafTree : void 0),
+          inputProps: {
+            ...inputProps,
+            autofocus: autofocus.value
+          },
+          treeProps: tree?.lazyLoad ? {
+            ...treeProps,
+            label: onlyLeaf ? renderTreeLabel : treeProps?.label,
+            lazy: true,
+            load: (node) => loadTreeChildren(node)
+          } : onlyLeaf ? { ...treeProps, label: renderTreeLabel } : treeProps,
+          onFocus: reOnFocus,
+          onChange: reOnChange
+        },
+        serviceOptions: {
+          service,
+          manual,
+          transformParams,
+          transformRes,
+          onBefore,
+          onAfter,
+          onSuccess,
+          onError
+        }
+      };
+    });
+    const lazyLoad = computed(() => props.tree?.lazyLoad);
+    const maxLevel = computed(() => props.tree?.maxLevel);
+    const normalizedData = computed(() => normalizeTree(data.value || []));
+    const {
+      firstLoad,
+      loading,
+      error,
+      refresh: requestRefresh,
+      refreshAsync: requestRefreshAsync,
+      cancel
+    } = useServiceLoadMore({
+      ...reProps.value.serviceOptions,
+      pagination: false,
+      onSuccess: (res) => {
+        reProps.value.serviceOptions.onSuccess?.(res);
+        data.value = res.list;
+      }
+    });
+    const treeSelectLoading = computed(() => reProps.value.externalLoading || loading.value);
+    function getTreeKeys() {
+      const keys = props.keys;
+      return {
+        value: keys?.value || "value",
+        label: keys?.label || "label",
+        children: keys?.children || "children"
+      };
+    }
+    function canLazyLoad(level) {
+      return lazyLoad.value && (maxLevel.value === void 0 || level < maxLevel.value);
+    }
+    function renderTreeLabel(createElement, node) {
+      const label = props.treeProps?.label;
+      const content = typeof label === "function" ? label(createElement, node) : typeof label === "string" ? label : label === false ? null : node.label;
+      const children = node.getChildren(false);
+      const leaf = children !== true && (!Array.isArray(children) || children.length === 0);
+      return createElement(
+        "span",
+        { class: { "qd-service-tree-select__label--disabled": !leaf } },
+        content
+      );
+    }
+    function isTreeNodeMatched(filterWords, node) {
+      const label = node.data[getTreeKeys().label];
+      return String(label ?? "").toLowerCase().includes(filterWords);
+    }
+    function hasMatchedTreeNodeChildren(filterWords, node) {
+      const children = node.getChildren(true);
+      return Array.isArray(children) && children.some((child) => isTreeNodeMatched(filterWords, child));
+    }
+    function filterOnlyLeafTree(filterWords, node) {
+      const keyword = filterWords.trim().toLowerCase();
+      const matched = isTreeNodeMatched(keyword, node);
+      const hasMatchedChildren = hasMatchedTreeNodeChildren(keyword, node);
+      if (matched || hasMatchedChildren) return true;
+      return node.getParents().some(
+        (parent) => isTreeNodeMatched(keyword, parent) && !hasMatchedTreeNodeChildren(keyword, parent)
+      );
+    }
+    function normalizeTree(items, level = 0) {
+      const { children: childrenKey } = getTreeKeys();
+      return items.map((item) => {
+        const children = item[childrenKey];
+        const normalizedChildren = Array.isArray(children) ? normalizeTree(children, level + 1) : children === true ? canLazyLoad(level) ? true : [] : children === void 0 && canLazyLoad(level) ? true : children;
+        const leaf = normalizedChildren !== true && (!Array.isArray(normalizedChildren) || normalizedChildren.length === 0);
+        const normalizedItem = {
+          ...item,
+          [childrenKey]: normalizedChildren
+        };
+        if (!props.onlyLeaf) return normalizedItem;
+        if (props.multiple) return { ...normalizedItem, checkable: leaf };
+        return { ...normalizedItem, activable: leaf };
+      });
+    }
+    function registerNodeLabels(items) {
+      const { value: valueKey, label: labelKey, children: childrenKey } = getTreeKeys();
+      items.forEach((item) => {
+        const label = item[labelKey];
+        if (typeof label === "string" || typeof label === "number") {
+          nodeLabelMap.set(item[valueKey], String(label));
+        }
+        const children = item[childrenKey];
+        if (Array.isArray(children)) registerNodeLabels(children);
+      });
+    }
+    function getValueLabel(value) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const label = value[getTreeKeys().label];
+        return typeof label === "string" || typeof label === "number" ? String(label) : "";
+      }
+      return nodeLabelMap.get(value) || "";
+    }
+    function syncValueLabel(value, context) {
+      if (props.multiple) {
+        valueLabel.value = Array.isArray(value) ? value.map(getValueLabel).filter(Boolean) : [];
+        return;
+      }
+      const label = context.data?.[getTreeKeys().label];
+      valueLabel.value = typeof label === "string" || typeof label === "number" ? String(label) : getValueLabel(value);
+    }
+    function setTreeNodeState(node, state) {
+      const loadNode = node;
+      if (loadNode.set) {
+        loadNode.set(state);
+        return;
+      }
+      node.setData({ ...node.data, ...state });
+    }
+    async function requestTreeChildren(node) {
+      const { service, treeProps } = props;
+      const tree = reProps.value.tree;
+      let records;
+      if (!service) {
+        records = await treeProps?.load?.(node) || [];
+      } else {
+        const params = tree?.transformParams ? await tree.transformParams(node) : node;
+        const res = await service(params);
+        const transformed = tree?.transformRes ? await tree.transformRes(res, node) : res;
+        records = transformed?.records || [];
+      }
+      const children = normalizeTree(records, node.getLevel() + 1);
+      registerNodeLabels(children);
+      if (!children.length && props.onlyLeaf) {
+        setTreeNodeState(node, props.multiple ? { checkable: true } : { activable: true });
+      }
+      return children;
+    }
+    function loadTreeChildren(node) {
+      const nodeKey = node.value;
+      const pending = loadingNodes.get(nodeKey);
+      if (pending) return pending;
+      const request = requestTreeChildren(node);
+      loadingNodes.set(nodeKey, request);
+      return request.catch((err) => {
+        setTreeNodeState(node, { loading: false });
+        throw err;
+      }).finally(() => {
+        loadingNodes.delete(nodeKey);
+      });
+    }
+    function refresh() {
+      if (!props.service) return;
+      requestRefresh();
+    }
+    function refreshAsync() {
+      if (!props.service) return;
+      return requestRefreshAsync();
+    }
+    const expose = {
+      firstLoad,
+      loading,
+      error,
+      refresh,
+      refreshAsync,
+      cancel
+    };
+    watch(
+      () => [data.value, props.keys],
+      ([items]) => {
+        nodeLabelMap.clear();
+        registerNodeLabels(items || []);
+      },
+      { immediate: true, deep: true }
+    );
+    onMounted(() => {
+      autofocus.value = props.autofocus;
+    });
+    onActivated(() => {
+      autofocus.value = props.autofocus;
+    });
+    onDeactivated(() => {
+      autofocus.value = false;
+    });
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TreeSelect), mergeProps({
+        class: "qd-service-tree-select",
+        modelValue: unref(modelValue),
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(modelValue) ? modelValue.value = $event : null),
+        "input-value": unref(inputValue),
+        "onUpdate:inputValue": _cache[1] || (_cache[1] = ($event) => isRef(inputValue) ? inputValue.value = $event : null),
+        "popup-visible": unref(popupVisible),
+        "onUpdate:popupVisible": _cache[2] || (_cache[2] = ($event) => isRef(popupVisible) ? popupVisible.value = $event : null),
+        data: normalizedData.value,
+        loading: treeSelectLoading.value
+      }, reProps.value.treeSelectOptions), createSlots({ _: 2 }, [
+        renderList(_ctx.$slots, (_, name) => {
+          return {
+            name,
+            fn: withCtx((slotProps) => [
+              renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)))
+            ])
+          };
+        })
+      ]), 1040, ["modelValue", "input-value", "popup-visible", "data", "loading"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/service-tree-select/index.vue3.mjs

@@ -0,0 +1,6 @@
+import './index.css'
+import _sfc_main from "./index.vue.mjs";
+/* empty css            */
+export {
+  _sfc_main as default
+};

package/dist/components/service-tree-select/props.d.ts

@@ -0,0 +1,6 @@
+export declare const qdServiceTreeSelectProps: {
+    readonly data: () => never[];
+    readonly manual: undefined;
+    readonly loading: undefined;
+    readonly onlyLeaf: false;
+};

package/dist/components/service-tree-select/props.mjs

@@ -0,0 +1,9 @@
+const qdServiceTreeSelectProps = {
+  data: () => [],
+  manual: void 0,
+  loading: void 0,
+  onlyLeaf: false
+};
+export {
+  qdServiceTreeSelectProps
+};

package/dist/components/service-tree-select/types.d.ts

@@ -0,0 +1,18 @@
+import type { ServicePageLoadMoreOptions, ServicePageParams, ServicePageRes, useServiceLoadMore } from 'qidian-shared';
+import type { TdTreeSelectProps, TreeNodeModel, TreeOptionData } from 'tdesign-vue-next';
+export interface QdServiceTreeSelectTreeOptions<D extends TreeOptionData = TreeOptionData, R = unknown, TP = TreeNodeModel<D>> {
+    lazyLoad?: boolean;
+    maxLevel?: number;
+    transformParams?: (node: TreeNodeModel<D>) => TP | Promise<TP>;
+    transformRes?: (res: R, node: TreeNodeModel<D>) => ServicePageRes<D> | Promise<ServicePageRes<D>>;
+}
+export interface QdServiceTreeSelectProps<D extends TreeOptionData = TreeOptionData, R = unknown, P = ServicePageParams, TP = P> extends TdTreeSelectProps<D>, Omit<ServicePageLoadMoreOptions<D, R, P, TP, false>, 'pagination' | 'transformParams' | 'transformRes'> {
+    data?: D[];
+    autofocus?: boolean;
+    onlyLeaf?: boolean;
+    valueLabel?: string | string[];
+    tree?: QdServiceTreeSelectTreeOptions<D, R, TP>;
+    transformParams?: (params: undefined) => TP | Promise<TP>;
+    transformRes?: (res: R) => ServicePageRes<D> | Promise<ServicePageRes<D>>;
+}
+export type QdServiceTreeSelectInstanceFunctions<D extends TreeOptionData = TreeOptionData, R = unknown, P = ServicePageParams, TP = P> = Pick<ReturnType<typeof useServiceLoadMore<D, R, P, TP, false>>, 'firstLoad' | 'loading' | 'error' | 'refresh' | 'refreshAsync' | 'cancel'>;

package/dist/index.mjs

@@ -11,45 +11,47 @@ import { default as default8 } from "./components/import-dialog/index.vue.mjs";
 import { default as default9 } from "./components/input-number/index.vue.mjs";
 import { default as default10 } from "./components/org/select/index.vue.mjs";
 /* empty css                                  */
-import { default as default11 } from "./components/auto-tooltip/index.vue.mjs";
-import { default as default12 } from "./components/avatar/index.vue.mjs";
-import { default as default13 } from "./components/card/index.vue.mjs";
-import { default as default14 } from "./components/columns-controller/index.vue.mjs";
+import { default as default11 } from "./components/service-tree-select/index.vue.mjs";
+/* empty css                                           */
+import { default as default12 } from "./components/auto-tooltip/index.vue.mjs";
+import { default as default13 } from "./components/avatar/index.vue.mjs";
+import { default as default14 } from "./components/card/index.vue.mjs";
+import { default as default15 } from "./components/columns-controller/index.vue.mjs";
 import { useConfig } from "./components/config-provider/useConfig.mjs";
 import { QdConfigProvider } from "./components/config-provider/index.mjs";
 import { qdAsyncCompute, qdCompute, qdUseComputeValue } from "./components/config-renderer/compute.mjs";
 import { getValueByPath, parseVModelPath, resolveVModelBinding, setValueByPath } from "./components/config-renderer/utils.mjs";
 import { defineQdCrudList, defineQdCrudTable, defineQdCrudTabsTable } from "./components/crud/define.mjs";
-import { default as default15 } from "./components/crud/list/index.vue.mjs";
-import { default as default16 } from "./components/crud/search/index.vue.mjs";
-import { default as default17 } from "./components/crud/table/index.vue.mjs";
-import { default as default18 } from "./components/crud/tabs-table/index.vue.mjs";
-import { default as default19 } from "./components/dict/checkbox-group/index.vue.mjs";
-import { default as default20 } from "./components/dict/radio-group/index.vue.mjs";
-import { default as default21 } from "./components/dict/tag/index.vue.mjs";
-import { default as default22 } from "./components/file-icon/index.vue.mjs";
+import { default as default16 } from "./components/crud/list/index.vue.mjs";
+import { default as default17 } from "./components/crud/search/index.vue.mjs";
+import { default as default18 } from "./components/crud/table/index.vue.mjs";
+import { default as default19 } from "./components/crud/tabs-table/index.vue.mjs";
+import { default as default20 } from "./components/dict/checkbox-group/index.vue.mjs";
+import { default as default21 } from "./components/dict/radio-group/index.vue.mjs";
+import { default as default22 } from "./components/dict/tag/index.vue.mjs";
+import { default as default23 } from "./components/file-icon/index.vue.mjs";
 import { PROVIDE_FORM_ADD_AFTER_SUBMIT_QUEUE, PROVIDE_FORM_ADD_BEFORE_SUBMIT_QUEUE, PROVIDE_FORM_RESET_QUEUE } from "./components/form/config.mjs";
-import { default as default23 } from "./components/form/index.vue.mjs";
-import { default as default24 } from "./components/form/item.vue.mjs";
+import { default as default24 } from "./components/form/index.vue.mjs";
+import { default as default25 } from "./components/form/item.vue.mjs";
 import { qdFormGrid, qdFormGutter } from "./components/form/props.mjs";
 import { PROVIDE_GRID_ITEM_PROPS_KEY, PROVIDE_GRID_WIDTH_KEY } from "./components/grid/config.mjs";
-import { default as default25 } from "./components/grid/index.vue.mjs";
-import { default as default26 } from "./components/grid/item.vue.mjs";
-import { default as default27 } from "./components/left-ribbon-tag/index.vue.mjs";
-import { default as default28 } from "./components/org/tag/index.vue.mjs";
-import { default as default29 } from "./components/read-write/index.vue.mjs";
-import { default as default30 } from "./components/service/list/index.vue.mjs";
-import { default as default31 } from "./components/service/table/index.vue.mjs";
-import { default as default32 } from "./components/service-dialog-table-select/index.vue.mjs";
+import { default as default26 } from "./components/grid/index.vue.mjs";
+import { default as default27 } from "./components/grid/item.vue.mjs";
+import { default as default28 } from "./components/left-ribbon-tag/index.vue.mjs";
+import { default as default29 } from "./components/org/tag/index.vue.mjs";
+import { default as default30 } from "./components/read-write/index.vue.mjs";
+import { default as default31 } from "./components/service/list/index.vue.mjs";
+import { default as default32 } from "./components/service/table/index.vue.mjs";
+import { default as default33 } from "./components/service-dialog-table-select/index.vue.mjs";
 import { defineQdServiceDialogTableSelect } from "./components/service-dialog-table-select/define.mjs";
-import { default as default33 } from "./components/service-dialog-tabs-table-select/index.vue.mjs";
+import { default as default34 } from "./components/service-dialog-tabs-table-select/index.vue.mjs";
 import { defineQdServiceDialogTabsTableSelect } from "./components/service-dialog-tabs-table-select/define.mjs";
-import { default as default34 } from "./components/service-popup-table-select/index.vue.mjs";
+import { default as default35 } from "./components/service-popup-table-select/index.vue.mjs";
 import { defineQdServicePopupTableSelect } from "./components/service-popup-table-select/define.mjs";
-import { default as default35 } from "./components/service-select/index.vue.mjs";
-import { default as default36 } from "./components/steps/index.vue.mjs";
+import { default as default36 } from "./components/service-select/index.vue.mjs";
+import { default as default37 } from "./components/steps/index.vue.mjs";
 import { qdUploadAcceptMap } from "./components/upload/config.mjs";
-import { default as default37 } from "./components/upload/index.vue.mjs";
+import { default as default38 } from "./components/upload/index.vue.mjs";
 import { hasPermi, hasPermiDirective } from "./directive/hasPermi.mjs";
 import { hasRole, hasRoleDirective } from "./directive/hasRole.mjs";
 import { useAgentChat } from "./hooks/useAgentChat/index.mjs";
@@ -70,43 +72,44 @@ export {
   PROVIDE_FORM_RESET_QUEUE,
   PROVIDE_GRID_ITEM_PROPS_KEY,
   PROVIDE_GRID_WIDTH_KEY,
-  default11 as QdAutoTooltip,
-  default12 as QdAvatar,
-  default13 as QdCard,
-  default14 as QdColumnsController,
+  default12 as QdAutoTooltip,
+  default13 as QdAvatar,
+  default14 as QdCard,
+  default15 as QdColumnsController,
   QdConfigProvider,
   default2 as QdConfigRenderer,
-  default15 as QdCrudList,
-  default16 as QdCrudSearch,
-  default17 as QdCrudTable,
-  default18 as QdCrudTabsTable,
+  default16 as QdCrudList,
+  default17 as QdCrudSearch,
+  default18 as QdCrudTable,
+  default19 as QdCrudTabsTable,
   default4 as QdDialog,
   default3 as QdDialogForm,
-  default19 as QdDictCheckboxGroup,
-  default20 as QdDictRadioGroup,
+  default20 as QdDictCheckboxGroup,
+  default21 as QdDictRadioGroup,
   default5 as QdDictSelect,
-  default21 as QdDictTag,
+  default22 as QdDictTag,
   default6 as QdDrawer,
-  default22 as QdFileIcon,
-  default23 as QdForm,
-  default24 as QdFormItem,
-  default25 as QdGrid,
-  default26 as QdGridItem,
+  default23 as QdFileIcon,
+  default24 as QdForm,
+  default25 as QdFormItem,
+  default26 as QdGrid,
+  default27 as QdGridItem,
   default7 as QdImage,
   default8 as QdImportDialog,
   default9 as QdInputNumber,
-  default27 as QdLeftRibbonTag,
+  default28 as QdLeftRibbonTag,
   default10 as QdOrgSelect,
-  default28 as QdOrgTag,
-  default29 as QdReadWrite,
-  default32 as QdServiceDialogTableSelect,
-  default33 as QdServiceDialogTabsTableSelect,
-  default30 as QdServiceList,
-  default34 as QdServicePopupTableSelect,
-  default35 as QdServiceSelect,
-  default31 as QdServiceTable,
-  default36 as QdSteps,
-  default37 as QdUpload,
+  default29 as QdOrgTag,
+  default30 as QdReadWrite,
+  default33 as QdServiceDialogTableSelect,
+  default34 as QdServiceDialogTabsTableSelect,
+  default31 as QdServiceList,
+  default35 as QdServicePopupTableSelect,
+  default36 as QdServiceSelect,
+  default32 as QdServiceTable,
+  default11 as QdServiceTreeSelect,
+  default37 as QdSteps,
+  default38 as QdUpload,
   auth,
   defineQdCrudList,
   defineQdCrudTable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qidian-vue-ui",
-  "version": "2.0.15",
+  "version": "2.0.17",
   "description": "基于 TDesign 的 QiDian Vue UI 组件库",
   "author": "qidian",
   "license": "MIT",