vft 0.0.375 → 0.0.376

package/es/components/select/option-item.vue.js

@@ -1,31 +1,31 @@
-import _sfc_main from "./option-item.vue2.js";
-import { createElementBlock, openBlock, withModifiers, normalizeClass, normalizeStyle, renderSlot, createElementVNode, toDisplayString } from "vue";
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-const _hoisted_1 = ["aria-selected"];
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("li", {
-    "aria-selected": _ctx.selected,
-    style: normalizeStyle(_ctx.style),
-    class: normalizeClass([
-      _ctx.ns.be("dropdown", "item"),
-      _ctx.ns.is("selected", _ctx.selected),
-      _ctx.ns.is("disabled", _ctx.disabled),
-      _ctx.ns.is("created", _ctx.created),
-      _ctx.ns.is("hovering", _ctx.hovering)
+import o from "./option-item.vue2.js";
+import { createElementBlock as l, openBlock as n, withModifiers as r, normalizeClass as d, normalizeStyle as t, renderSlot as a, createElementVNode as m, toDisplayString as p } from "vue";
+import f from "../../_virtual/_plugin-vue_export-helper.js";
+const u = ["aria-selected"];
+function b(e, s, k, v, $, g) {
+  return n(), l("li", {
+    "aria-selected": e.selected,
+    style: t(e.style),
+    class: d([
+      e.ns.be("dropdown", "item"),
+      e.ns.is("selected", e.selected),
+      e.ns.is("disabled", e.disabled),
+      e.ns.is("created", e.created),
+      e.ns.is("hovering", e.hovering)
     ]),
-    onMousemove: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
-    onClick: _cache[1] || (_cache[1] = withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
+    onMousemove: s[0] || (s[0] = (...i) => e.hoverItem && e.hoverItem(...i)),
+    onClick: s[1] || (s[1] = r((...i) => e.selectOptionClick && e.selectOptionClick(...i), ["stop"]))
   }, [
-    renderSlot(_ctx.$slots, "default", {
-      item: _ctx.item,
-      index: _ctx.index,
-      disabled: _ctx.disabled
+    a(e.$slots, "default", {
+      item: e.item,
+      index: e.index,
+      disabled: e.disabled
     }, () => [
-      createElementVNode("span", null, toDisplayString(_ctx.getLabel(_ctx.item)), 1)
+      m("span", null, p(e.getLabel(e.item)), 1)
     ])
-  ], 46, _hoisted_1);
+  ], 46, u);
 }
-const OptionItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+const I = /* @__PURE__ */ f(o, [["render", b]]);
 export {
-  OptionItem as default
+  I as default
 };

package/es/components/select/option-item.vue2.js

@@ -1,32 +1,29 @@
-import { defineComponent, inject } from "vue";
+import { defineComponent as s, inject as n } from "vue";
 import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useNamespace } from "../../hooks/use-namespace/index.js";
+import { useNamespace as c } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-import { useOption } from "./useOption.js";
-import { useProps } from "./useProps.js";
-import { optionV2Emits, optionV2Props } from "./defaults.js";
-import { selectV2InjectionKey } from "./token.js";
-const _sfc_main = defineComponent({
-  props: optionV2Props,
-  emits: optionV2Emits,
-  setup(props, { emit }) {
-    const select = inject(selectV2InjectionKey);
-    const ns = useNamespace("select");
-    const { hoverItem, selectOptionClick } = useOption(props, { emit });
-    const { getLabel } = useProps(select.props);
+import { useOption as f } from "./useOption.js";
+import { useProps as l } from "./useProps.js";
+import { optionV2Emits as a, optionV2Props as u } from "./defaults.js";
+import { selectV2InjectionKey as V } from "./token.js";
+const y = s({
+  props: u,
+  emits: a,
+  setup(o, { emit: t }) {
+    const e = n(V), p = c("select"), { hoverItem: r, selectOptionClick: m } = f(o, { emit: t }), { getLabel: i } = l(e.props);
     return {
-      ns,
-      hoverItem,
-      selectOptionClick,
-      getLabel
+      ns: p,
+      hoverItem: r,
+      selectOptionClick: m,
+      getLabel: i
     };
   }
 });
 export {
-  _sfc_main as default
+  y as default
 };

package/es/components/select/select-dropdown.js

@@ -1,241 +1,184 @@
-import { defineComponent, inject, ref, computed, watch, unref, createVNode, mergeProps, toRaw } from "vue";
-import { get } from "lodash-es";
-import { isUndefined, isIOS, isObject } from "@vft/utils";
-import FixedSizeList from "../virtual-list/components/fixed-size-list.js";
-import DynamicSizeList from "../virtual-list/components/dynamic-size-list.js";
+import { defineComponent as _, inject as $, ref as H, computed as f, watch as J, unref as h, createVNode as p, mergeProps as D, toRaw as Q } from "vue";
+import { get as b } from "lodash-es";
+import { isUndefined as W, isIOS as X, isObject as K } from "@vft/utils";
+import Y from "../virtual-list/components/fixed-size-list.js";
+import Z from "../virtual-list/components/dynamic-size-list.js";
 import "../virtual-list/components/fixed-size-grid.js";
 import "../virtual-list/components/dynamic-size-grid.js";
 import "../virtual-list/props.js";
 import "@vueuse/core";
 import "../config-provider/hooks/use-global-config.js";
-import { EVENT_CODE } from "../../constants/aria.js";
-import { useNamespace } from "../../hooks/use-namespace/index.js";
+import { EVENT_CODE as ee } from "../../constants/aria.js";
+import { useNamespace as te } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-import GroupItem from "./group-item.vue.js";
-import OptionItem from "./option-item.vue.js";
-import { useProps } from "./useProps.js";
-import { selectV2InjectionKey } from "./token.js";
-const props = {
+import oe from "./group-item.vue.js";
+import re from "./option-item.vue.js";
+import { useProps as se } from "./useProps.js";
+import { selectV2InjectionKey as ne } from "./token.js";
+const ie = {
   loading: Boolean,
   data: {
     type: Array,
-    required: true
+    required: !0
   },
   hoveringIndex: Number,
   width: Number
-};
-const SelectMenu = /* @__PURE__ */ defineComponent({
+}, Ne = /* @__PURE__ */ _({
   name: "ElSelectDropdown",
-  props,
-  setup(props2, {
-    slots,
-    expose
+  props: ie,
+  setup(w, {
+    slots: m,
+    expose: N
   }) {
-    const select = inject(selectV2InjectionKey);
-    const ns = useNamespace("select");
-    const {
-      getLabel,
-      getValue,
-      getDisabled
-    } = useProps(select.props);
-    const cachedHeights = ref([]);
-    const listRef = ref();
-    const size = computed(() => props2.data.length);
-    watch(() => size.value, () => {
-      select.tooltipRef.value?.updatePopper?.();
-    });
-    const isSized = computed(() => isUndefined(select.props.estimatedOptionHeight));
-    const listProps = computed(() => {
-      if (isSized.value) {
-        return {
-          itemSize: select.props.itemHeight
-        };
-      }
-      return {
-        estimatedSize: select.props.estimatedOptionHeight,
-        itemSize: (idx) => cachedHeights.value[idx]
-      };
+    const o = $(ne), S = te("select"), {
+      getLabel: T,
+      getValue: g,
+      getDisabled: k
+    } = se(o.props), E = H([]), d = H(), L = f(() => w.data.length);
+    J(() => L.value, () => {
+      o.tooltipRef.value?.updatePopper?.();
     });
-    const contains = (arr = [], target) => {
+    const u = f(() => W(o.props.estimatedOptionHeight)), v = f(() => u.value ? {
+      itemSize: o.props.itemHeight
+    } : {
+      estimatedSize: o.props.estimatedOptionHeight,
+      itemSize: (e) => E.value[e]
+    }), A = (e = [], t) => {
       const {
         props: {
-          valueKey
+          valueKey: r
         }
-      } = select;
-      if (!isObject(target)) {
-        return arr.includes(target);
-      }
-      return arr && arr.some((item) => {
-        return toRaw(get(item, valueKey)) === get(target, valueKey);
-      });
-    };
-    const isEqual = (selected, target) => {
-      if (!isObject(target)) {
-        return selected === target;
-      } else {
+      } = o;
+      return K(t) ? e && e.some((s) => Q(b(s, r)) === b(t, r)) : e.includes(t);
+    }, P = (e, t) => {
+      if (K(t)) {
         const {
-          valueKey
-        } = select.props;
-        return get(selected, valueKey) === get(target, valueKey);
-      }
-    };
-    const isItemSelected = (modelValue, target) => {
-      if (select.props.multiple) {
-        return contains(modelValue, getValue(target));
-      }
-      return isEqual(modelValue, getValue(target));
-    };
-    const isItemDisabled = (modelValue, selected) => {
+          valueKey: r
+        } = o.props;
+        return b(e, r) === b(t, r);
+      } else
+        return e === t;
+    }, y = (e, t) => o.props.multiple ? A(e, g(t)) : P(e, g(t)), I = (e, t) => {
       const {
-        disabled,
-        multiple,
-        multipleLimit
-      } = select.props;
-      return disabled || !selected && (multiple ? multipleLimit > 0 && modelValue.length >= multipleLimit : false);
-    };
-    const isItemHovering = (target) => props2.hoveringIndex === target;
-    const scrollToItem = (index) => {
-      const list = listRef.value;
-      if (list) {
-        list.scrollToItem(index);
+        disabled: r,
+        multiple: s,
+        multipleLimit: n
+      } = o.props;
+      return r || !t && (s ? n > 0 && e.length >= n : !1);
+    }, z = (e) => w.hoveringIndex === e;
+    N({
+      listRef: d,
+      isSized: u,
+      isItemDisabled: I,
+      isItemHovering: z,
+      isItemSelected: y,
+      scrollToItem: (e) => {
+        const t = d.value;
+        t && t.scrollToItem(e);
+      },
+      resetScrollTop: () => {
+        const e = d.value;
+        e && e.resetScrollTop();
       }
-    };
-    const resetScrollTop = () => {
-      const list = listRef.value;
-      if (list) {
-        list.resetScrollTop();
-      }
-    };
-    const exposed = {
-      listRef,
-      isSized,
-      isItemDisabled,
-      isItemHovering,
-      isItemSelected,
-      scrollToItem,
-      resetScrollTop
-    };
-    expose(exposed);
-    const Item = (itemProps) => {
-      const {
-        index,
-        data,
-        style
-      } = itemProps;
-      const sized = unref(isSized);
-      const {
-        itemSize,
-        estimatedSize
-      } = unref(listProps);
-      const {
-        modelValue
-      } = select.props;
+    });
+    const V = (e) => {
       const {
-        onSelect,
-        onHover
-      } = select;
-      const item = data[index];
-      if (item.type === "Group") {
-        return createVNode(GroupItem, {
-          "item": item,
-          "style": style,
-          "height": sized ? itemSize : estimatedSize
+        index: t,
+        data: r,
+        style: s
+      } = e, n = h(u), {
+        itemSize: l,
+        estimatedSize: a
+      } = h(v), {
+        modelValue: i
+      } = o.props, {
+        onSelect: C,
+        onHover: F
+      } = o, c = r[t];
+      if (c.type === "Group")
+        return p(oe, {
+          item: c,
+          style: s,
+          height: n ? l : a
         }, null);
-      }
-      const isSelected = isItemSelected(modelValue, item);
-      const isDisabled = isItemDisabled(modelValue, isSelected);
-      const isHovering = isItemHovering(index);
-      return createVNode(OptionItem, mergeProps(itemProps, {
-        "selected": isSelected,
-        "disabled": getDisabled(item) || isDisabled,
-        "created": !!item.created,
-        "hovering": isHovering,
-        "item": item,
-        "onSelect": onSelect,
-        "onHover": onHover
+      const x = y(i, c), G = I(i, x), M = z(t);
+      return p(re, D(e, {
+        selected: x,
+        disabled: k(c) || G,
+        created: !!c.created,
+        hovering: M,
+        item: c,
+        onSelect: C,
+        onHover: F
       }), {
-        default: (props3) => slots.default?.(props3) || createVNode("span", null, [getLabel(item)])
+        default: (U) => m.default?.(U) || p("span", null, [T(c)])
       });
-    };
-    const {
-      onKeyboardNavigate,
-      onKeyboardSelect
-    } = select;
-    const onForward = () => {
-      onKeyboardNavigate("forward");
-    };
-    const onBackward = () => {
-      onKeyboardNavigate("backward");
-    };
-    const onKeydown = (e) => {
-      const {
-        code
-      } = e;
+    }, {
+      onKeyboardNavigate: O,
+      onKeyboardSelect: j
+    } = o, R = () => {
+      O("forward");
+    }, q = () => {
+      O("backward");
+    }, B = (e) => {
       const {
-        tab,
-        esc,
-        down,
-        up,
-        enter,
-        numpadEnter
-      } = EVENT_CODE;
-      if ([esc, down, up, enter, numpadEnter].includes(code)) {
-        e.preventDefault();
-        e.stopPropagation();
-      }
-      switch (code) {
-        case tab:
-        case esc:
+        code: t
+      } = e, {
+        tab: r,
+        esc: s,
+        down: n,
+        up: l,
+        enter: a,
+        numpadEnter: i
+      } = ee;
+      switch ([s, n, l, a, i].includes(t) && (e.preventDefault(), e.stopPropagation()), t) {
+        case r:
+        case s:
           break;
-        case down:
-          onForward();
+        case n:
+          R();
           break;
-        case up:
-          onBackward();
+        case l:
+          q();
           break;
-        case enter:
-        case numpadEnter:
-          onKeyboardSelect();
+        case a:
+        case i:
+          j();
           break;
       }
     };
     return () => {
       const {
-        data,
-        width
-      } = props2;
-      const {
-        height,
-        multiple,
-        scrollbarAlwaysOn
-      } = select.props;
-      const isScrollbarAlwaysOn = computed(() => {
-        return isIOS ? true : scrollbarAlwaysOn;
-      });
-      const List = unref(isSized) ? FixedSizeList : DynamicSizeList;
-      return createVNode("div", {
-        "class": [ns.b("dropdown"), ns.is("multiple", multiple)],
-        "style": {
-          width: `${width}px`
+        data: e,
+        width: t
+      } = w, {
+        height: r,
+        multiple: s,
+        scrollbarAlwaysOn: n
+      } = o.props, l = f(() => X ? !0 : n), a = h(u) ? Y : Z;
+      return p("div", {
+        class: [S.b("dropdown"), S.is("multiple", s)],
+        style: {
+          width: `${t}px`
         }
-      }, [slots.header?.(), slots.loading?.() || slots.empty?.() || createVNode(List, mergeProps({
-        "ref": listRef
-      }, unref(listProps), {
-        "className": ns.be("dropdown", "list"),
-        "scrollbarAlwaysOn": isScrollbarAlwaysOn.value,
-        "data": data,
-        "height": height,
-        "width": width,
-        "total": data.length,
-        "onKeydown": onKeydown
+      }, [m.header?.(), m.loading?.() || m.empty?.() || p(a, D({
+        ref: d
+      }, h(v), {
+        className: S.be("dropdown", "list"),
+        scrollbarAlwaysOn: l.value,
+        data: e,
+        height: r,
+        width: t,
+        total: e.length,
+        onKeydown: B
       }), {
-        default: (props3) => createVNode(Item, props3, null)
-      }), slots.footer?.()]);
+        default: (i) => p(V, i, null)
+      }), m.footer?.()]);
     };
   }
 });
 export {
-  SelectMenu as default
+  Ne as default
 };