qidian-vue-ui 2.3.2 → 2.3.3

package/dist/components/service-popup-table-select/index2.css

@@ -0,0 +1,26 @@
+.qd-popup-table-select__table[data-v-d0befc95] .qd-crud-search > .t-loading__parent > .t-card__body,
+.qd-popup-table-select__table[data-v-d0befc95] .qd-crud-table__body > .t-loading__parent > .t-card__body {
+  padding: 0 !important;
+}
+.qd-popup-table-select__table[data-v-d0befc95] .qd-crud-table__toolbar {
+  display: none;
+}
+.qd-popup-table-select__table[data-v-d0befc95] .qd-crud-table__body {
+  margin-top: 0 !important;
+}
+.qd-popup-table-select__table[data-v-d0befc95] .qd-service-table {
+  margin-top: 0;
+}
+.qd-popup-table-select__table-add[data-v-d0befc95] {
+  margin-top: var(--td-comp-margin-m);
+  display: flex;
+}
+.qd-popup-table-select__table-add .t-input__wrap[data-v-d0befc95] {
+  flex: 1 1 0;
+  overflow: hidden;
+  margin-right: var(--td-comp-margin-m);
+}
+.qd-popup-table-select__input-trigger[data-v-d0befc95] {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}

package/dist/components/service-popup-table-select/props.d.ts

@@ -0,0 +1,47 @@
+export declare const qdServicePopupTableSelectProps: {
+    readonly searchData: () => {};
+    readonly multiple: false;
+    readonly readonly: undefined;
+    readonly disabled: undefined;
+    readonly clearable: false;
+    readonly valueType: "value";
+    readonly mode: "select";
+    readonly data: () => never[];
+    readonly columnControllerVisible: undefined;
+    readonly expandedRowKeys: () => never[];
+    readonly filterValue: undefined;
+    readonly sort: undefined;
+    readonly expandedTreeNodes: () => never[];
+    readonly emptyText: undefined;
+    readonly emptyImage: true;
+    readonly lazyForm: true;
+    readonly widthCompensation: true;
+    readonly editCellValidationBlock: "error";
+    readonly cellSelectable: undefined;
+    readonly cellClipboard: true;
+    readonly onCellCopy: undefined;
+    readonly onCellPaste: undefined;
+    readonly expandIcon: true;
+    readonly selectOnRowClick: undefined;
+    readonly bordered: undefined;
+    readonly keyboardRowHover: true;
+    readonly showHeader: true;
+    readonly maxHeight: "100%";
+    readonly hover: true;
+    readonly reserveSelectedRowOnFilter: false;
+    readonly expandOnRowClick: undefined;
+    readonly hideSortTips: undefined;
+    readonly multipleSort: true;
+    readonly rowSelectionAllowUncheck: undefined;
+    readonly disableSpaceInactiveRow: undefined;
+    readonly horizontalScrollAffixedBottom: true;
+    readonly paginationAffixedBottom: undefined;
+    readonly pagination: undefined;
+    readonly headerBg: true;
+    readonly showFilterResult: false;
+    readonly loadingWithData: true;
+    readonly headerAffixedTop: true;
+};
+export declare const qdServicePopupProps: {
+    readonly placement: "bottom-left";
+};

package/dist/components/service-popup-table-select/props.mjs

@@ -0,0 +1,26 @@
+import { qdServiceTableProps } from "../service/table/props.mjs";
+const {
+  selectedRowKeys,
+  activeRowKeys,
+  activeRowType,
+  rowKey,
+  reserveSelectedRowOnPaginate,
+  ...qdServiceTableOtherProps
+} = qdServiceTableProps;
+const qdServicePopupTableSelectProps = {
+  ...qdServiceTableOtherProps,
+  searchData: () => ({}),
+  multiple: false,
+  readonly: void 0,
+  disabled: void 0,
+  clearable: false,
+  valueType: "value",
+  mode: "select"
+};
+const qdServicePopupProps = {
+  placement: "bottom-left"
+};
+export {
+  qdServicePopupProps,
+  qdServicePopupTableSelectProps
+};

package/dist/components/service-popup-table-select/types.d.ts

@@ -0,0 +1,16 @@
+import type { ServicePageParams, ServicePagination } from 'qidian-shared';
+import type { KeysType, TableRowData, TdButtonProps, TdInputProps } from 'tdesign-vue-next';
+import type { QdCrudTableInstanceFunctions, QdCrudTableProps } from '../crud';
+import type { QdServiceTablePagination } from '../service';
+import type { QdServiceSelectProps } from '../service-select';
+export interface QdServicePopupTableSelectProps<D extends TableRowData = TableRowData, R = unknown, P = ServicePageParams, TP = P, Pag extends ServicePagination = QdServiceTablePagination> extends Omit<QdCrudTableProps<D, R, P, TP, Pag>, 'add' | 'actions' | 'edit' | 'view' | 'del' | 'rowActions' | 'form' | 'fitParentHeight' | 'selectedRowKeys' | 'activeRowKeys' | 'activeRowType' | 'rowKey' | 'selectType' | 'size' | 'reserveSelectedRowOnPaginate' | 'onAsyncLoadingClick' | 'onCellClick' | 'onChange' | 'onColumnChange' | 'onColumnControllerVisibleChange' | 'onDataChange' | 'onDisplayColumnsChange' | 'onDragSort' | 'onExpandChange' | 'onFilterChange' | 'onRowEdit' | 'onRowValidate' | 'onSelectChange' | 'onSortChange' | 'onValidate'>, Pick<QdServiceSelectProps<D, R, P, TP, Pag>, 'modelValue' | 'multiple' | 'readonly' | 'disabled' | 'placeholder' | 'clearable' | 'creatable' | 'size' | 'valueType' | 'fillOptions' | 'popupVisible' | 'popupProps' | 'onClear' | 'onCreate' | 'onChange'> {
+    keys?: KeysType;
+    tableSize?: QdCrudTableProps['size'];
+    addBtn?: string | TdButtonProps | null;
+    addConfirmBtn?: string | TdButtonProps | null;
+    addCancelBtn?: string | TdButtonProps | null;
+    addInput?: string | TdInputProps | null;
+    mode?: 'select' | 'input';
+    quoteBtn?: string | TdButtonProps | null;
+}
+export type QdServicePopupTableSelectInstanceFunctions = QdCrudTableInstanceFunctions;

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

@@ -0,0 +1,6 @@
+.qd-service-select__load[data-v-5d80d43f] {
+  width: 100%;
+  border-top: 1px solid var(--td-component-stroke);
+  padding: 6px;
+  color: var(--td-text-color-disabled);
+}

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

@@ -0,0 +1,2 @@
+export { default as QdServiceSelect } from './index.vue';
+export type { QdServiceSelectInstanceFunctions, QdServiceSelectProps } from './types';

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

@@ -0,0 +1,30 @@
+import type { ServicePageParams, ServicePagination } from 'qidian-shared';
+import type { SelectOption } from 'tdesign-vue-next';
+import type { QdServiceSelectInstanceFunctions, QdServiceSelectProps } from './types';
+declare const _default: <D extends SelectOption = SelectOption, R = unknown, P = ServicePageParams, TP = P, Pag extends ServicePagination = ServicePagination, SK extends string | string[] = string | string[]>(__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: import("tdesign-vue-next").SelectValue<SelectOption> | 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;
+        readonly "onUpdate:options"?: ((args_0: D[] | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:valueLabel" | "onUpdate:inputValue" | "onUpdate:popupVisible" | "onUpdate:options"> & QdServiceSelectProps<D, R, P, TP, Pag, SK> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<QdServiceSelectInstanceFunctions<D, R, P, TP, Pag>>): void;
+    attrs: any;
+    slots: {
+        [x: number]: ((props: any) => any) | undefined;
+    } & {
+        'panel-bottom-content'?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            options: D[];
+        }) => any;
+    };
+    emit: ((evt: "update:modelValue", args_0: import("tdesign-vue-next").SelectValue<SelectOption> | 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) & ((evt: "update:options", args_0: D[] | 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-select/index.vue.mjs

@@ -0,0 +1,10 @@
+import './index2.css'
+import './index.css'
+import _sfc_main from "./index.vue2.mjs";
+/* empty css            */
+/* empty css            */
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const QdServiceSelect = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-5d80d43f"]]);
+export {
+  QdServiceSelect as default
+};

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

@@ -0,0 +1,510 @@
+import './index2.css'
+import './index.css'
+import { defineComponent, mergeDefaults, computed, ref, unref, watch, onMounted, onActivated, onDeactivated, createBlock, openBlock, mergeProps, isRef, createSlots, withCtx, renderSlot, createCommentVNode, renderList, 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 { isEmpty, toArr, useServiceLoadMore, extractSlotsWithoutPrefix, checkSameObject } from "qidian-shared";
+import { Select, Loading } from "tdesign-vue-next";
+import { useConfig } from "../config-provider/useConfig.mjs";
+import { qdDictConvStrSeparator } from "../dict/tag/props.mjs";
+import { qdServiceSelectKeys, qdServiceSelectProps } from "./props.mjs";
+const QD_FILL_OPTION_MARK = "__qdFillOption";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "QdServiceSelect"
+  },
+  __name: "index",
+  props: /* @__PURE__ */ mergeDefaults({
+    defaultSelectFirst: { type: Boolean },
+    convStr: { type: [Boolean, String] },
+    valueLabel: {},
+    searchKey: {},
+    fillOptions: {},
+    transformParams: { type: Function },
+    autoWidth: { type: Boolean },
+    autofocus: { type: Boolean },
+    borderless: { type: Boolean },
+    clearable: { type: Boolean },
+    collapsedItems: {},
+    creatable: { type: Boolean },
+    disabled: { type: Boolean },
+    empty: {},
+    filter: { type: Function },
+    filterable: { type: Boolean },
+    inputProps: {},
+    inputValue: {},
+    defaultInputValue: {},
+    keys: {},
+    label: {},
+    loading: { type: Boolean },
+    loadingText: {},
+    max: {},
+    minCollapsedNum: {},
+    multiple: { type: Boolean },
+    options: {},
+    panelBottomContent: {},
+    panelTopContent: {},
+    placeholder: {},
+    popupProps: {},
+    popupVisible: { type: Boolean },
+    defaultPopupVisible: { type: Boolean },
+    prefixIcon: {},
+    readonly: { type: Boolean },
+    reserveKeyword: { type: Boolean },
+    scroll: {},
+    selectInputProps: {},
+    showArrow: { type: Boolean },
+    size: {},
+    status: {},
+    suffix: {},
+    suffixIcon: {},
+    tagInputProps: {},
+    tagProps: {},
+    tips: {},
+    value: {},
+    defaultValue: {},
+    modelValue: {},
+    valueDisplay: {},
+    valueType: {},
+    onBlur: { type: Function },
+    onChange: { type: Function },
+    onClear: { type: Function },
+    onCreate: { type: Function },
+    onEnter: { 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 },
+    transformRes: { type: Function },
+    pagination: {}
+  }, qdServiceSelectProps),
+  emits: ["update:modelValue", "update:valueLabel", "update:inputValue", "update:popupVisible", "update:options"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { modelValue, valueLabel, inputValue, popupVisible, options } = useVModels(props, emit, {
+      passive: true
+    });
+    const reModelValue = computed({
+      get: () => {
+        const { convStr, selectOptions } = reProps.value;
+        const { multiple, valueType } = selectOptions;
+        if (!multiple || valueType === "object") return modelValue.value;
+        if (isEmpty(modelValue.value)) return [];
+        if (typeof modelValue.value === "string") {
+          return modelValue.value.split(
+            (typeof convStr === "string" ? convStr : "") || qdDictConvStrSeparator
+          );
+        }
+        return modelValue.value;
+      },
+      set: (val) => {
+        const { convStr, selectOptions } = reProps.value;
+        const { multiple, valueType } = selectOptions;
+        if (!multiple || valueType === "object") {
+          modelValue.value = val;
+          return;
+        }
+        if (convStr && Array.isArray(val)) {
+          modelValue.value = val.join(
+            (typeof convStr === "string" ? convStr : "") || qdDictConvStrSeparator
+          );
+        } else {
+          modelValue.value = val;
+        }
+      }
+    });
+    const reValueLabel = computed({
+      get: () => {
+        const { convStr, selectOptions } = reProps.value;
+        const { multiple, valueType } = selectOptions;
+        if (!multiple || valueType === "object") return valueLabel.value;
+        if (isEmpty(valueLabel.value)) return [];
+        if (typeof valueLabel.value === "string") {
+          return valueLabel.value.split(
+            (typeof convStr === "string" ? convStr : "") || qdDictConvStrSeparator
+          );
+        }
+        return valueLabel.value;
+      },
+      set: (val) => {
+        const { convStr, selectOptions } = reProps.value;
+        const { multiple, valueType } = selectOptions;
+        if (!multiple || valueType === "object") {
+          valueLabel.value = val;
+          return;
+        }
+        if (convStr && Array.isArray(val)) {
+          valueLabel.value = val.join(
+            (typeof convStr === "string" ? convStr : "") || qdDictConvStrSeparator
+          );
+        } else {
+          valueLabel.value = val;
+        }
+      }
+    });
+    const { t: loadingT } = useConfig("loading");
+    const { t: serviceSelectT } = useConfig("serviceSelect");
+    const search = ref("");
+    const searchPending = ref(false);
+    const autofocus = ref(false);
+    const createOptionText = computed(() => JSON.stringify(serviceSelectT("createText")));
+    let autoOpenedOnce = false;
+    const reProps = computed(() => {
+      const {
+        service,
+        manual,
+        transformParams,
+        transformRes,
+        pagination,
+        onBefore,
+        onAfter,
+        onSuccess,
+        onError,
+        convStr,
+        searchKey,
+        loading: externalLoad,
+        defaultSelectFirst,
+        fillOptions,
+        modelValue: modelValue2,
+        inputValue: inputValue2,
+        popupVisible: inPopupVisible,
+        options: inOptions,
+        valueLabel: valueLabel2,
+        popupProps,
+        creatable,
+        filterable,
+        filter,
+        autofocus: autofocus2,
+        onSearch,
+        onInputChange,
+        onPopupVisibleChange,
+        onFocus,
+        onCreate,
+        onChange,
+        ...selectOptions
+      } = props;
+      const mergedManual = manual ?? unref(pagination) !== false;
+      const rePopupProps = {
+        ...popupProps,
+        overlayClassName: ["qd-service-select__popup", popupProps?.overlayClassName],
+        overlayStyle: (triggerElement, popupElement) => ({
+          ...typeof popupProps?.overlayStyle === "function" ? popupProps.overlayStyle(triggerElement, popupElement) : popupProps?.overlayStyle,
+          "--qd-service-select-create-text": createOptionText.value
+        }),
+        onScrollToBottom: (context) => {
+          popupProps?.onScrollToBottom?.(context);
+          if (loading.value || noMore.value) return;
+          loadMore();
+        }
+      };
+      const reOnSearch = (filterWords, context) => {
+        onSearch?.(filterWords, context);
+        search.value = filterWords.trim();
+        refresh();
+      };
+      const reOnInputChange = (value, context) => {
+        onInputChange?.(value, context);
+        search.value = String(value ?? "").trim();
+        searchPending.value = !!service && !!search.value;
+      };
+      const reOnPopupVisibleChange = (visible, context) => {
+        onPopupVisibleChange?.(visible, context);
+        if (!service || loading.value) return;
+        if (visible && (search.value || !options.value?.length || triggerServiceMerged && checkSameObject(options.value, markedFillOptions.value))) {
+          search.value = "";
+          refresh();
+        }
+      };
+      const reOnFocus = (context) => {
+        onFocus?.(context);
+        if (autofocus2 && !autoOpenedOnce && !popupVisible.value) {
+          autoOpenedOnce = true;
+          popupVisible.value = true;
+        }
+      };
+      const reOnCreate = (value) => {
+        if (!reCreatable.value) return;
+        onCreate?.(value);
+      };
+      const reOnChange = (value, context) => {
+        onChange?.(value, context);
+        const { selectOptions: selectOptions2 } = reProps.value;
+        const { multiple, keys } = selectOptions2;
+        const labelKey = keys?.label || qdServiceSelectKeys.label;
+        if (multiple) {
+          const selectedLabels = context.selectedOptions?.map((option) => option[labelKey]).filter(Boolean) || [];
+          reValueLabel.value = selectedLabels;
+        } else {
+          reValueLabel.value = context.option?.[labelKey] || "";
+        }
+      };
+      const reSearchKey = toArr(searchKey);
+      const mergedTransformParams = (params) => {
+        const searchData = {};
+        reSearchKey.forEach((key) => {
+          searchData[key] = search.value;
+        });
+        const merged = !params && !reSearchKey.length ? params : { ...params, ...searchData };
+        if (transformParams)
+          return transformParams(merged);
+        return merged;
+      };
+      const reFilterable = filterable ?? !!reSearchKey.length;
+      const reFilter = filter ?? (reFilterable ? handleFilter : void 0);
+      const mergedOnSearch = service && reSearchKey.length ? reOnSearch : void 0;
+      return {
+        autofocus: autofocus2,
+        externalLoad,
+        defaultSelectFirst,
+        fillOptions,
+        convStr,
+        creatable,
+        selectOptions: {
+          ...selectOptions,
+          filterable: reFilterable,
+          filter: reFilter,
+          popupProps: rePopupProps,
+          onSearch: mergedOnSearch,
+          onInputChange: reOnInputChange,
+          onPopupVisibleChange: reOnPopupVisibleChange,
+          onFocus: reOnFocus,
+          onCreate: reOnCreate,
+          onChange: reOnChange
+        },
+        serviceOptions: {
+          service,
+          manual: mergedManual,
+          transformParams: mergedTransformParams,
+          transformRes,
+          pagination,
+          onBefore,
+          onAfter,
+          onSuccess,
+          onError
+        },
+        models: {
+          modelValue: modelValue2,
+          valueLabel: valueLabel2,
+          inputValue: inputValue2,
+          popupVisible: inPopupVisible,
+          options: inOptions
+        }
+      };
+    });
+    const markedFillOptions = computed(
+      () => (reProps.value.fillOptions || []).map((opt) => ({
+        ...opt,
+        [QD_FILL_OPTION_MARK]: true
+      }))
+    );
+    let hasAutoSelected = false;
+    let unWatchAutoSelected;
+    let triggerServiceMerged = false;
+    const {
+      data,
+      firstLoad,
+      manualTriggerLoad,
+      loading,
+      loadingMore,
+      noMore,
+      error,
+      refresh,
+      refreshAsync,
+      cancel,
+      loadMore,
+      loadMoreAsync
+    } = useServiceLoadMore({
+      ...reProps.value.serviceOptions,
+      onBefore: () => {
+        reProps.value.serviceOptions.onBefore?.();
+      },
+      onAfter: () => {
+        searchPending.value = false;
+        reProps.value.serviceOptions.onAfter?.();
+      },
+      onSuccess: (res) => {
+        reProps.value.serviceOptions.onSuccess?.(res);
+        const list = data.value?.list || [];
+        const fillOpts = markedFillOptions.value;
+        if (fillOpts.length && !search.value) {
+          const valueKey = reProps.value.selectOptions.keys?.value || qdServiceSelectKeys.value;
+          const listKeys = new Set(list.map((item) => item[valueKey]));
+          const map = /* @__PURE__ */ new Map();
+          [...fillOpts.filter((item) => !listKeys.has(item[valueKey])), ...list].forEach((item) => {
+            const k = item[valueKey];
+            map.set(k, item);
+          });
+          options.value = Array.from(map.values());
+        } else {
+          options.value = list;
+        }
+        triggerServiceMerged = true;
+        setDefaultSelectFirst(res.list);
+      }
+    });
+    const selectLoad = computed(() => reProps.value.externalLoad || firstLoad.value);
+    const reCreatable = computed(() => {
+      if (!reProps.value.creatable || !reProps.value.selectOptions.filterable || selectLoad.value || loading.value || searchPending.value) {
+        return false;
+      }
+      const value = search.value;
+      if (!value) return false;
+      const labelKey = reProps.value.selectOptions.keys?.label || qdServiceSelectKeys.label;
+      return !options.value?.some(
+        (option) => String(option[labelKey] ?? "").trim() === value
+      );
+    });
+    function handleFilter(filterWords, option) {
+      if (!filterWords) return true;
+      if ("value" in option) {
+        if (reProps.value.selectOptions.multiple) {
+          if (reModelValue.value.includes(option.value)) return true;
+        } else if (reModelValue.value === option.value) {
+          return true;
+        }
+      }
+      if (!option.label) return false;
+      const value = filterWords.trim().toLowerCase();
+      return option.label.toLowerCase().includes(value);
+    }
+    function getSelectedOptions(value) {
+      const values = Array.isArray(value) ? value : [value];
+      const valueKey = reProps.value.selectOptions.keys?.value || qdServiceSelectKeys.value;
+      return (options.value || []).filter(
+        (option) => values.some(
+          (item) => typeof item === "object" && item !== null ? item[valueKey] === option[valueKey] : item === option[valueKey]
+        )
+      );
+    }
+    function handleKeydownCapture(event) {
+      if (event.key !== "Enter" || event.isComposing || !reCreatable.value) return;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      const value = search.value;
+      const { multiple, onEnter, onCreate, onChange } = reProps.value.selectOptions;
+      const currentValue = reModelValue.value;
+      const selectedOptions = getSelectedOptions(currentValue);
+      const nextValue = multiple ? [...Array.isArray(currentValue) ? currentValue : [], value] : value;
+      onEnter?.({ inputValue: value, e: event, value: currentValue });
+      onCreate?.(value);
+      reModelValue.value = nextValue;
+      onChange?.(nextValue, { selectedOptions, trigger: "check", e: event });
+      popupVisible.value = false;
+    }
+    function setAutoSelectedWatch() {
+      if (!reProps.value.defaultSelectFirst) return;
+      unWatchAutoSelected = watch(options, setDefaultSelectFirst, { immediate: true });
+    }
+    function setDefaultSelectFirst(data2) {
+      if (!hasAutoSelected && reProps.value.defaultSelectFirst && isEmpty(reModelValue.value) && data2.length) {
+        const firstOption = data2[0];
+        const { keys, multiple, valueType } = reProps.value.selectOptions;
+        const firstValue = valueType === "object" ? firstOption : firstOption[keys?.value || qdServiceSelectKeys.value];
+        reModelValue.value = multiple ? [firstValue] : firstValue;
+        unWatchAutoSelected?.();
+        hasAutoSelected = true;
+      }
+    }
+    const expose = {
+      firstLoad,
+      manualTriggerLoad,
+      loading,
+      loadingMore,
+      noMore,
+      error,
+      refresh,
+      refreshAsync,
+      cancel,
+      loadMore,
+      loadMoreAsync
+    };
+    watch(
+      markedFillOptions,
+      (fillOpts) => {
+        const currentOptions = (options.value || []).filter(
+          (opt) => !opt[QD_FILL_OPTION_MARK]
+        );
+        if (!fillOpts?.length || search.value) {
+          options.value = currentOptions;
+          return;
+        }
+        const valueKey = reProps.value.selectOptions.keys?.value || qdServiceSelectKeys.value;
+        const currentKeys = new Set(currentOptions.map((item) => item[valueKey]));
+        const map = /* @__PURE__ */ new Map();
+        [...fillOpts.filter((item) => !currentKeys.has(item[valueKey])), ...currentOptions].forEach(
+          (item) => {
+            const k = item[valueKey];
+            map.set(k, item);
+          }
+        );
+        options.value = Array.from(map.values());
+        triggerServiceMerged = true;
+      },
+      { immediate: true, deep: true }
+    );
+    setAutoSelectedWatch();
+    onMounted(() => {
+      autofocus.value = reProps.value.autofocus;
+    });
+    onActivated(() => {
+      autofocus.value = reProps.value.autofocus;
+    });
+    onDeactivated(() => {
+      autofocus.value = false;
+    });
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Select), mergeProps({
+        class: "qd-service-select",
+        modelValue: reModelValue.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => reModelValue.value = $event),
+        input: unref(inputValue),
+        "onUpdate:input": _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),
+        autofocus: autofocus.value,
+        loading: selectLoad.value
+      }, {
+        ...reProps.value.selectOptions,
+        ..._ctx.$slots.default ? {} : { options: unref(options) }
+      }, {
+        creatable: reCreatable.value,
+        onKeydownCapture: handleKeydownCapture
+      }), createSlots({
+        "panel-bottom-content": withCtx(() => [
+          unref(loading) && !unref(firstLoad) ? (openBlock(), createBlock(unref(Loading), {
+            key: 0,
+            class: "qd-service-select__load",
+            size: "small",
+            text: unref(loadingT)("text")
+          }, null, 8, ["text"])) : _ctx.$slots["panel-bottom-content"] ? renderSlot(_ctx.$slots, "panel-bottom-content", { key: 1 }, void 0, true) : createCommentVNode("", true)
+        ]),
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {
+            options: unref(options)
+          }, void 0, true)
+        ]),
+        _: 2
+      }, [
+        renderList(unref(extractSlotsWithoutPrefix)(_ctx.$slots, "panel-bottom"), (_, name) => {
+          return {
+            name,
+            fn: withCtx((slotProps) => [
+              renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+            ])
+          };
+        })
+      ]), 1040, ["modelValue", "input", "popup-visible", "autofocus", "loading", "creatable"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};