yc-design-vue 1.0.1

package/es/Select/Select.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Select.vue2.js";
+/* empty css            */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const _Select = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b6b51f16"]]);
+export {
+  _Select as default
+};

package/es/Select/Select.vue2.js

@@ -0,0 +1,304 @@
+import { defineComponent, toRefs, ref, computed, createBlock, openBlock, unref, mergeProps, isRef, withCtx, createElementVNode, normalizeStyle, normalizeClass, renderSlot, createVNode, toDisplayString, createCommentVNode } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { sleep } from "../_shared/utils/fn.js";
+import { isUndefined } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useContext from "./hooks/useContext.js";
+import SelectIcon from "./SelectIcon.vue.js";
+import SelectView from "./SelectView.vue.js";
+import Input from "../Input/index.js";
+import InputTag from "../InputTag/index.js";
+import Trigger from "../Trigger/index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Select"
+  },
+  __name: "Select",
+  props: {
+    multiple: { type: Boolean, default: false },
+    modelValue: { type: [String, Number, Boolean, Object, Array], default: void 0 },
+    defaultValue: { type: [String, Number, Boolean, Object, Array], default: (props) => {
+      return props.multiple ? [] : "";
+    } },
+    inputValue: { default: void 0 },
+    defaultInputValue: { default: "" },
+    size: { default: void 0 },
+    placeholder: { default: "" },
+    loading: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    error: { type: Boolean, default: false },
+    allowClear: { type: Boolean, default: false },
+    allowSearch: { type: Boolean, default: (props) => {
+      return props.multiple;
+    } },
+    allowCreate: { type: Boolean, default: false },
+    maxTagCount: { default: 0 },
+    popupContainer: { default: void 0 },
+    bordered: { type: Boolean, default: true },
+    defaultActivefirstOption: { type: Boolean, default: false },
+    popupVisible: { type: Boolean, default: void 0 },
+    defaultPopupVisible: { type: Boolean, default: false },
+    unmountonClose: { type: Boolean },
+    filterOption: { type: [Boolean, Function], default: void 0 },
+    options: { default: () => [] },
+    virtualListProps: { default: void 0 },
+    triggerProps: { default: () => {
+      return {
+        contentStyle: {}
+      };
+    } },
+    formatLabel: {},
+    fallbackOption: {},
+    showExtraOptions: { type: Boolean, default: true },
+    valueKey: { default: "" },
+    searchDelay: { default: 500 },
+    limit: { default: 0 },
+    fieldNames: { default: () => {
+      return {};
+    } },
+    scrollbar: { type: Boolean, default: true },
+    showHeaderOnEmpty: { type: Boolean, default: false },
+    showFooterOnEmpty: { type: Boolean, default: false },
+    tagNowrap: { type: Boolean, default: false },
+    hotkeys: { type: Boolean },
+    showEmpty: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "update:inputValue", "update:popupVisible", "change", "input-value-change", "clear", "remove", "search", "exceedLimit", "popup-visible-change", "dropdown-scroll", "dropdown-reach-bottom", "select"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      allowClear,
+      disabled,
+      loading,
+      searchDelay,
+      showFooterOnEmpty,
+      showHeaderOnEmpty,
+      multiple,
+      allowSearch,
+      allowCreate,
+      virtualListProps
+    } = toRefs(props);
+    const inputRef = ref();
+    const popupRef = ref();
+    const {
+      computedVisible,
+      computedValue,
+      computedInputValue,
+      selectOptions,
+      createOptions
+    } = useContext().provide(props, emits, inputRef);
+    const showClearBtn = computed(() => {
+      const hasValue = multiple.value ? computedValue.value.length : String(computedValue.value).length;
+      return allowClear.value && !disabled.value && !loading.value && !!hasValue;
+    });
+    const isReadonly = computed(() => {
+      return (!allowSearch.value || loading.value) && !allowCreate.value && isUndefined(props.filterOption);
+    });
+    const handleEvent = async (type, value = "") => {
+      var _a, _b, _c;
+      switch (type) {
+        case "create":
+          {
+            if (!allowCreate.value) return;
+            const target = createOptions.value.find(
+              (item) => item == computedInputValue.value
+            );
+            if (target) return;
+            createOptions.value.push({
+              label: computedInputValue.value,
+              value: computedInputValue.value
+            });
+            if (allowSearch.value) {
+              (_a = inputRef.value) == null ? void 0 : _a.blur();
+            }
+          }
+          break;
+        case "clear":
+          {
+            computedValue.value = multiple.value ? [] : "";
+            emits("clear");
+          }
+          break;
+        case "search":
+          {
+            await sleep(searchDelay.value);
+            emits("search", value);
+          }
+          break;
+        case "focus":
+          {
+            if (disabled.value) return;
+            if (computedVisible.value) {
+              return (_b = inputRef.value) == null ? void 0 : _b.blur();
+            }
+            computedVisible.value = true;
+            await sleep(0);
+            (_c = inputRef.value) == null ? void 0 : _c.focus();
+          }
+          break;
+        case "blur":
+          {
+            computedVisible.value = false;
+          }
+          break;
+        case "updateValue":
+          {
+            computedValue.value = value.map(
+              (item) => item.value
+            );
+          }
+          break;
+      }
+    };
+    __expose({
+      focus() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      },
+      blur() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.blur();
+      },
+      getPopupRef() {
+        return popupRef.value;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Trigger), mergeProps({
+        "popup-visible": unref(computedVisible),
+        "onUpdate:popupVisible": _cache[14] || (_cache[14] = ($event) => isRef(computedVisible) ? computedVisible.value = $event : null),
+        "unmount-on-close": _ctx.unmountonClose,
+        "popup-container": _ctx.popupContainer,
+        disabled: unref(disabled),
+        "popup-offset": 4,
+        trigger: "focus",
+        position: "bl",
+        "animation-name": "slide-dynamic-origin",
+        "need-transform-origin": "",
+        "auto-fit-popup-width": "",
+        "prevent-focus": "",
+        ref_key: "popupRef",
+        ref: popupRef
+      }, _ctx.triggerProps), {
+        content: withCtx(() => [
+          createVNode(SelectView, {
+            loading: unref(loading),
+            scrollbar: _ctx.scrollbar,
+            "virtual-list-props": unref(virtualListProps),
+            "show-footer-on-empty": unref(showFooterOnEmpty),
+            "show-header-on-empty": unref(showHeaderOnEmpty)
+          }, null, 8, ["loading", "scrollbar", "virtual-list-props", "show-footer-on-empty", "show-header-on-empty"])
+        ]),
+        default: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass([
+              "yc-select",
+              {
+                "yc-select-allow-search": unref(allowSearch),
+                "yc-select-allow-clear": showClearBtn.value,
+                "yc-select-no-border": !_ctx.bordered
+              },
+              _ctx.$attrs.class
+            ]),
+            style: normalizeStyle(_ctx.$attrs.style)
+          }, [
+            renderSlot(_ctx.$slots, "trigger", {}, () => {
+              var _a;
+              return [
+                !unref(multiple) ? (openBlock(), createBlock(unref(Input), {
+                  key: 0,
+                  modelValue: unref(computedInputValue),
+                  "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(computedInputValue) ? computedInputValue.value = $event : null),
+                  "show-input": unref(computedVisible),
+                  readonly: isReadonly.value,
+                  disabled: unref(disabled),
+                  size: _ctx.size,
+                  error: _ctx.error,
+                  placeholder: ((_a = unref(selectOptions)[0]) == null ? void 0 : _a.label) || "",
+                  ref_key: "inputRef",
+                  ref: inputRef,
+                  onClick: _cache[2] || (_cache[2] = ($event) => handleEvent("focus")),
+                  onBlur: _cache[3] || (_cache[3] = ($event) => handleEvent("blur")),
+                  onInput: _cache[4] || (_cache[4] = (v) => handleEvent("search", v)),
+                  onPressEnter: _cache[5] || (_cache[5] = ($event) => handleEvent("create"))
+                }, {
+                  label: withCtx(() => [
+                    renderSlot(_ctx.$slots, "label", {
+                      data: unref(selectOptions)[0]
+                    }, () => {
+                      var _a2;
+                      return [
+                        createElementVNode("span", {
+                          class: normalizeClass([
+                            {
+                              "yc-input-placeholder": !unref(selectOptions).length
+                            }
+                          ])
+                        }, toDisplayString(((_a2 = unref(selectOptions)[0]) == null ? void 0 : _a2.label) || _ctx.placeholder), 3)
+                      ];
+                    }, true)
+                  ]),
+                  suffix: withCtx(() => [
+                    createVNode(SelectIcon, {
+                      "popup-visible": unref(computedVisible),
+                      "allow-search": unref(allowSearch),
+                      loading: unref(loading),
+                      "show-clear-btn": showClearBtn.value,
+                      onClear: _cache[0] || (_cache[0] = ($event) => handleEvent("clear"))
+                    }, null, 8, ["popup-visible", "allow-search", "loading", "show-clear-btn"])
+                  ]),
+                  _: 3
+                }, 8, ["modelValue", "show-input", "readonly", "disabled", "size", "error", "placeholder"])) : (openBlock(), createBlock(unref(InputTag), {
+                  key: 1,
+                  "input-value": unref(computedInputValue),
+                  "onUpdate:inputValue": _cache[7] || (_cache[7] = ($event) => isRef(computedInputValue) ? computedInputValue.value = $event : null),
+                  "model-value": unref(selectOptions),
+                  placeholder: _ctx.placeholder,
+                  readonly: isReadonly.value,
+                  disabled: unref(disabled),
+                  size: _ctx.size,
+                  error: _ctx.error,
+                  "max-tag-count": _ctx.maxTagCount,
+                  "tag-nowrap": _ctx.tagNowrap,
+                  ref_key: "inputRef",
+                  ref: inputRef,
+                  onFocus: _cache[8] || (_cache[8] = ($event) => handleEvent("focus")),
+                  onBlur: _cache[9] || (_cache[9] = ($event) => handleEvent("blur")),
+                  onInput: _cache[10] || (_cache[10] = (v) => handleEvent("search", v)),
+                  onRemove: _cache[11] || (_cache[11] = (v, ev) => _ctx.$emit("remove", v, ev)),
+                  onPressEnter: _cache[12] || (_cache[12] = ($event) => handleEvent("create")),
+                  "onUpdate:modelValue": _cache[13] || (_cache[13] = (v) => handleEvent("updateValue", v))
+                }, {
+                  tag: withCtx(({ tag }) => [
+                    _ctx.$slots.label ? renderSlot(_ctx.$slots, "label", {
+                      key: 0,
+                      data: tag
+                    }, void 0, true) : createCommentVNode("", true)
+                  ]),
+                  suffix: withCtx(() => [
+                    createVNode(SelectIcon, {
+                      "popup-visible": unref(computedVisible),
+                      "allow-search": unref(allowSearch),
+                      loading: unref(loading),
+                      "show-clear-btn": showClearBtn.value,
+                      onClear: _cache[6] || (_cache[6] = ($event) => handleEvent("clear"))
+                    }, null, 8, ["popup-visible", "allow-search", "loading", "show-clear-btn"])
+                  ]),
+                  _: 3
+                }, 8, ["input-value", "model-value", "placeholder", "readonly", "disabled", "size", "error", "max-tag-count", "tag-nowrap"]))
+              ];
+            }, true)
+          ], 6)
+        ]),
+        _: 3
+      }, 16, ["popup-visible", "unmount-on-close", "popup-container", "disabled"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Select/SelectIcon.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    loading: boolean;
+    popupVisible: boolean;
+    showClearBtn: boolean;
+    allowSearch: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/Select/SelectIcon.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./SelectIcon.vue2.js";
+/* empty css                */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const SelectIcon = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-6c36ec15"]]);
+export {
+  SelectIcon as default
+};

package/es/Select/SelectIcon.vue2.js

@@ -0,0 +1,66 @@
+import { defineComponent, resolveComponent, createBlock, createElementBlock, openBlock, unref, createSlots, withCtx, resolveDynamicComponent, Fragment, createElementVNode, createCommentVNode, withModifiers } from "vue";
+import useContext from "./hooks/useContext.js";
+import _sfc_main$1 from "../_shared/icons/IconArrowDown.vue.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import IconButton from "../_shared/components/IconButton.vue.js";
+/* empty css                                         */
+import Spin from "../Spin/index.js";
+const _hoisted_1 = { class: "yc-select-suffix-icon" };
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-select-search-icon"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SelectIcon",
+  props: {
+    loading: { type: Boolean },
+    popupVisible: { type: Boolean },
+    showClearBtn: { type: Boolean },
+    allowSearch: { type: Boolean }
+  },
+  emits: ["clear"],
+  setup(__props) {
+    const { slots } = useContext().inject();
+    const renderIcon = (name) => {
+      return slots[name];
+    };
+    return (_ctx, _cache) => {
+      const _component_icon_search = resolveComponent("icon-search");
+      return _ctx.loading ? (openBlock(), createBlock(unref(Spin), {
+        key: 0,
+        size: 12,
+        class: "yc-select-loading-icon"
+      }, createSlots({ _: 2 }, [
+        _ctx.$slots["loading-icon"] ? {
+          name: "icon",
+          fn: withCtx(() => [
+            (openBlock(), createBlock(resolveDynamicComponent(renderIcon("loading-icon"))))
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1024)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+        createElementVNode("div", _hoisted_1, [
+          unref(slots)["arrow-icon"] ? (openBlock(), createBlock(resolveDynamicComponent(renderIcon("arrow-icon")), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$1), {
+            key: 1,
+            rotate: _ctx.popupVisible ? 180 : 0
+          }, null, 8, ["rotate"]))
+        ]),
+        _ctx.allowSearch ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          unref(slots)["search-icon"] ? (openBlock(), createBlock(resolveDynamicComponent(renderIcon("search-icon")), { key: 0 })) : (openBlock(), createBlock(_component_icon_search, { key: 1 }))
+        ])) : createCommentVNode("", true),
+        _ctx.showClearBtn ? (openBlock(), createBlock(unref(IconButton), {
+          key: 1,
+          class: "yc-select-clear-icon",
+          onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.$emit("clear"), ["stop"]))
+        })) : createCommentVNode("", true)
+      ], 64));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Select/SelectRealList.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    scrollbar: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    getScrollRef(): HTMLDivElement | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/Select/SelectRealList.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./SelectRealList.vue2.js";
+/* empty css                    */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const SelectRealList = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-5c59943b"]]);
+export {
+  SelectRealList as default
+};

package/es/Select/SelectRealList.vue2.js

@@ -0,0 +1,95 @@
+import { defineComponent, ref, createBlock, openBlock, unref, withCtx, createElementVNode, createElementBlock, resolveDynamicComponent, Fragment, renderList } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import { getSlotFunction } from "../_shared/utils/vue-utils.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useContext from "./hooks/useContext.js";
+import Option from "./Option.vue.js";
+import Optgroup from "./Optgroup.vue.js";
+import Scrollbar from "../Scrollbar/index.js";
+const _hoisted_1 = { class: "yc-select-dropdown-list" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SelectRealList",
+  props: {
+    scrollbar: { type: Boolean }
+  },
+  setup(__props, { expose: __expose }) {
+    const { fieldKey, renderOptions, slots, emits } = useContext().inject();
+    const scrollbarRef = ref();
+    const renderLabel = (option) => {
+      if (slots.option) {
+        return () => {
+          var _a;
+          return ((_a = slots.option) == null ? void 0 : _a.call(slots, {
+            data: option
+          })) || [];
+        };
+      }
+      const { render, label } = fieldKey.value;
+      return getSlotFunction(option[render] ? option[render] : option[label]);
+    };
+    __expose({
+      getScrollRef() {
+        var _a;
+        return (_a = scrollbarRef.value) == null ? void 0 : _a.getScrollRef();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Scrollbar), {
+        scrollbar: _ctx.scrollbar,
+        class: "yc-select-dropdown-list-wrapper"
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            (openBlock(), createBlock(resolveDynamicComponent(unref(slots).default))),
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(renderOptions), (option) => {
+              return openBlock(), createElementBlock(Fragment, {
+                key: option.id
+              }, [
+                option.isGroup ? (openBlock(), createBlock(Optgroup, {
+                  key: 0,
+                  label: option.label
+                }, {
+                  default: withCtx(() => [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(option.options, (v) => {
+                      return openBlock(), createBlock(Option, {
+                        key: v[unref(fieldKey).value],
+                        value: v[unref(fieldKey).value],
+                        disabled: v[unref(fieldKey).disabled],
+                        "tag-props": v[unref(fieldKey).tagProps],
+                        "is-fallback-option": v[unref(fieldKey).isFallbackOption]
+                      }, {
+                        default: withCtx(() => [
+                          (openBlock(), createBlock(resolveDynamicComponent(renderLabel(v))))
+                        ]),
+                        _: 2
+                      }, 1032, ["value", "disabled", "tag-props", "is-fallback-option"]);
+                    }), 128))
+                  ]),
+                  _: 2
+                }, 1032, ["label"])) : (openBlock(), createBlock(Option, {
+                  key: 1,
+                  value: option[unref(fieldKey).value],
+                  disabled: option[unref(fieldKey).disabled],
+                  "tag-props": option[unref(fieldKey).tagProps],
+                  "is-fallback-option": option[unref(fieldKey).isFallbackOption]
+                }, {
+                  default: withCtx(() => [
+                    (openBlock(), createBlock(resolveDynamicComponent(renderLabel(option))))
+                  ]),
+                  _: 2
+                }, 1032, ["value", "disabled", "tag-props", "is-fallback-option"]))
+              ], 64);
+            }), 128))
+          ])
+        ]),
+        _: 1
+      }, 8, ["scrollbar"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Select/SelectView.vue.d.ts

@@ -0,0 +1,39 @@
+import { VirtualListProps } from './type';
+type __VLS_Props = {
+    loading: boolean;
+    scrollbar: boolean;
+    showFooterOnEmpty: boolean;
+    showHeaderOnEmpty: boolean;
+    virtualListProps?: VirtualListProps;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    virtualListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        virtualListProps: VirtualListProps;
+    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        virtualListProps: VirtualListProps;
+    }> & Readonly<{}>, {}, {}, {}, {}, {}> | null;
+    realListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        scrollbar: boolean;
+    }> & Readonly<{}>, {
+        getScrollRef(): HTMLDivElement | undefined;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        scrollbar: boolean;
+    }> & Readonly<{}>, {
+        getScrollRef(): HTMLDivElement | undefined;
+    }, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+export default _default;

package/es/Select/SelectView.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./SelectView.vue2.js";
+/* empty css                */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const SelectView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7ad0ee5e"]]);
+export {
+  SelectView as default
+};

package/es/Select/SelectView.vue2.js

@@ -0,0 +1,99 @@
+import { defineComponent, toRefs, ref, computed, createElementBlock, openBlock, createBlock, unref, createSlots, withCtx, resolveDynamicComponent, Fragment, createCommentVNode } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import { unrefElement } from "../_shared/utils/vue-utils.js";
+import { getGlobalConfig } from "../_shared/utils/global-config.js";
+import useContext from "./hooks/useContext.js";
+import useScrollReach from "../List/hooks/useScrollReach.js";
+import SelectVirtualList from "./SelectVirtualList.vue.js";
+import SelectRealList from "./SelectRealList.vue.js";
+import Spin from "../Spin/index.js";
+const _hoisted_1 = { class: "yc-select-dropdown" };
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-select-dropdown-header"
+};
+const _hoisted_3 = {
+  key: 4,
+  class: "yc-select-dropdown-footer"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SelectView",
+  props: {
+    loading: { type: Boolean },
+    scrollbar: { type: Boolean },
+    showFooterOnEmpty: { type: Boolean },
+    showHeaderOnEmpty: { type: Boolean },
+    virtualListProps: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { virtualListProps } = toRefs(props);
+    const { slots, options, isEmpty, emits } = useContext().inject();
+    const { renderEmpty } = getGlobalConfig();
+    const realListRef = ref();
+    const virtualListRef = ref();
+    const isVirtualList = computed(() => {
+      if (!virtualListProps.value) {
+        return false;
+      }
+      return virtualListProps.value.itemHeight && (!virtualListProps.value.threshold || virtualListProps.value.threshold > options.value.length);
+    });
+    const scrollRef = computed(() => {
+      var _a;
+      return isVirtualList.value ? unrefElement(virtualListRef) : (_a = realListRef.value) == null ? void 0 : _a.getScrollRef();
+    });
+    useScrollReach({
+      scrollRef,
+      onScroll: (e) => {
+        emits("dropdown-scroll", e);
+      },
+      onReachBottom: (e) => {
+        emits("dropdown-reach-bottom", e);
+      }
+    });
+    const renderSlots = (name) => {
+      return slots[name];
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        _ctx.loading ? (openBlock(), createBlock(unref(Spin), {
+          key: 0,
+          loading: _ctx.loading,
+          class: "yc-select-dropdown-loading"
+        }, createSlots({ _: 2 }, [
+          _ctx.$slots["loading-icon"] ? {
+            name: "icon",
+            fn: withCtx(() => [
+              (openBlock(), createBlock(resolveDynamicComponent(renderSlots("loading-icon"))))
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["loading"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          unref(slots).header && (_ctx.showHeaderOnEmpty || !unref(isEmpty)) ? (openBlock(), createElementBlock("div", _hoisted_2, [
+            (openBlock(), createBlock(resolveDynamicComponent(renderSlots("header"))))
+          ])) : createCommentVNode("", true),
+          isVirtualList.value ? (openBlock(), createBlock(SelectVirtualList, {
+            key: 1,
+            "virtual-list-props": unref(virtualListProps),
+            ref_key: "virtualListRef",
+            ref: virtualListRef
+          }, null, 8, ["virtual-list-props"])) : (openBlock(), createBlock(SelectRealList, {
+            key: 2,
+            scrollbar: _ctx.scrollbar,
+            ref_key: "realListRef",
+            ref: realListRef
+          }, null, 8, ["scrollbar"])),
+          unref(isEmpty) ? (openBlock(), createBlock(resolveDynamicComponent(unref(slots).empty || unref(renderEmpty)("Select")), { key: 3 })) : createCommentVNode("", true),
+          unref(slots).footer && (_ctx.showFooterOnEmpty || !unref(isEmpty)) ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            (openBlock(), createBlock(resolveDynamicComponent(renderSlots("footer"))))
+          ])) : createCommentVNode("", true)
+        ], 64))
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Select/SelectVirtualList.vue.d.ts

@@ -0,0 +1,6 @@
+import { VirtualListProps } from './index';
+type __VLS_Props = {
+    virtualListProps: VirtualListProps;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;