vft 0.0.369 → 0.0.370

package/es/components/select/select.vue2.js

@@ -1,76 +1,65 @@
-import { VftIcon } from "../icon/index.js";
-import { VftTag } from "../tag/index.js";
-import { VftTooltip } from "../tooltip/index.js";
+import { VftIcon as d } from "../icon/index.js";
+import { VftTag as u } from "../tag/index.js";
+import { VftTooltip as V } from "../tooltip/index.js";
 import "@vueuse/core";
-import { isArray } from "@vft/utils";
+import { isArray as b } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
-import { defineComponent, computed, reactive, toRefs, provide } from "vue";
+import { defineComponent as v, computed as l, reactive as n, toRefs as p, provide as S } from "vue";
 import "lodash-es";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-import { useCalcInputWidth } from "../../hooks/use-calc-input-width/index.js";
-import { ClickOutside } from "@vft/directives";
-import { selectV2Emits, selectV2Props } from "./defaults.js";
-import SelectMenu from "./select-dropdown.js";
-import { selectV2InjectionKey } from "./token.js";
-import useSelect from "./useSelect.js";
-const _sfc_main = defineComponent({
+import { useCalcInputWidth as y } from "../../hooks/use-calc-input-width/index.js";
+import { ClickOutside as g } from "@vft/directives";
+import { selectV2Emits as h, selectV2Props as I } from "./defaults.js";
+import K from "./select-dropdown.js";
+import { selectV2InjectionKey as R } from "./token.js";
+import T from "./useSelect.js";
+const B = v({
   name: "VftSelect",
   components: {
-    SelectMenu,
-    Tag: VftTag,
-    Tooltip: VftTooltip,
-    Icon: VftIcon
+    SelectMenu: K,
+    Tag: u,
+    Tooltip: V,
+    Icon: d
   },
-  directives: { ClickOutside },
-  props: selectV2Props,
-  emits: selectV2Emits,
-  setup(props, { emit }) {
-    const modelValue = computed(() => {
-      const { modelValue: rawModelValue, multiple } = props;
-      const fallback = multiple ? [] : void 0;
-      if (isArray(rawModelValue)) {
-        return multiple ? rawModelValue : fallback;
-      }
-      return multiple ? fallback : rawModelValue;
-    });
-    const API = useSelect(
-      reactive({
-        ...toRefs(props),
-        modelValue
+  directives: { ClickOutside: g },
+  props: I,
+  emits: h,
+  setup(o, { emit: a }) {
+    const r = l(() => {
+      const { modelValue: t, multiple: i } = o, m = i ? [] : void 0;
+      return b(t) ? i ? t : m : i ? m : t;
+    }), e = T(
+      n({
+        ...p(o),
+        modelValue: r
       }),
-      emit
-    );
-    const { calculatorRef, inputStyle } = useCalcInputWidth();
-    provide(selectV2InjectionKey, {
-      props: reactive({
-        ...toRefs(props),
-        height: API.popupHeight,
-        modelValue
+      a
+    ), { calculatorRef: c, inputStyle: s } = y();
+    S(R, {
+      props: n({
+        ...p(o),
+        height: e.popupHeight,
+        modelValue: r
       }),
-      expanded: API.expanded,
-      tooltipRef: API.tooltipRef,
-      onSelect: API.onSelect,
-      onHover: API.onHover,
-      onKeyboardNavigate: API.onKeyboardNavigate,
-      onKeyboardSelect: API.onKeyboardSelect
-    });
-    const selectedLabel = computed(() => {
-      if (!props.multiple) {
-        return API.states.selectedLabel;
-      }
-      return API.states.cachedOptions.map((i) => i.label);
+      expanded: e.expanded,
+      tooltipRef: e.tooltipRef,
+      onSelect: e.onSelect,
+      onHover: e.onHover,
+      onKeyboardNavigate: e.onKeyboardNavigate,
+      onKeyboardSelect: e.onKeyboardSelect
     });
+    const f = l(() => o.multiple ? e.states.cachedOptions.map((t) => t.label) : e.states.selectedLabel);
     return {
-      ...API,
-      modelValue,
-      selectedLabel,
-      calculatorRef,
-      inputStyle
+      ...e,
+      modelValue: r,
+      selectedLabel: f,
+      calculatorRef: c,
+      inputStyle: s
     };
   }
 });
 export {
-  _sfc_main as default
+  B as default
 };

package/es/components/select/token.js

@@ -1,6 +1,6 @@
-const selectV2InjectionKey = Symbol(
+const e = Symbol(
   "ElSelectV2Injection"
 );
 export {
-  selectV2InjectionKey
+  e as selectV2InjectionKey
 };

package/es/components/select/useAllowCreate.js

@@ -1,81 +1,51 @@
-import { ref, computed } from "vue";
-import { useProps } from "./useProps.js";
-function useAllowCreate(props, states) {
-  const { aliasProps, getLabel, getValue } = useProps(props);
-  const createOptionCount = ref(0);
-  const cachedSelectedOption = ref();
-  const enableAllowCreateMode = computed(() => {
-    return props.allowCreate && props.filterable;
-  });
-  function hasExistingOption(query) {
-    const hasOption = (option) => getLabel(option) === query;
-    return props.options && props.options.some(hasOption) || states.createdOptions.some(hasOption);
+import { ref as f, computed as m } from "vue";
+import { useProps as w } from "./useProps.js";
+function x(l, n) {
+  const { aliasProps: c, getLabel: r, getValue: u } = w(l), i = f(0), d = f(), a = m(() => l.allowCreate && l.filterable);
+  function O(e) {
+    const t = (o) => r(o) === e;
+    return l.options && l.options.some(t) || n.createdOptions.some(t);
   }
-  function selectNewOption(option) {
-    if (!enableAllowCreateMode.value) {
-      return;
-    }
-    if (props.multiple && option.created) {
-      createOptionCount.value++;
-    } else {
-      cachedSelectedOption.value = option;
-    }
+  function v(e) {
+    a.value && (l.multiple && e.created ? i.value++ : d.value = e);
   }
-  function createNewOption(query) {
-    if (enableAllowCreateMode.value) {
-      if (query && query.length > 0) {
-        if (hasExistingOption(query)) {
+  function p(e) {
+    if (a.value)
+      if (e && e.length > 0) {
+        if (O(e))
           return;
-        }
-        const newOption = {
-          [aliasProps.value.value]: query,
-          [aliasProps.value.label]: query,
-          created: true,
-          [aliasProps.value.disabled]: false
+        const t = {
+          [c.value.value]: e,
+          [c.value.label]: e,
+          created: !0,
+          [c.value.disabled]: !1
         };
-        if (states.createdOptions.length >= createOptionCount.value) {
-          states.createdOptions[createOptionCount.value] = newOption;
-        } else {
-          states.createdOptions.push(newOption);
-        }
-      } else {
-        if (props.multiple) {
-          states.createdOptions.length = createOptionCount.value;
-        } else {
-          const selectedOption = cachedSelectedOption.value;
-          states.createdOptions.length = 0;
-          if (selectedOption && selectedOption.created) {
-            states.createdOptions.push(selectedOption);
-          }
-        }
+        n.createdOptions.length >= i.value ? n.createdOptions[i.value] = t : n.createdOptions.push(t);
+      } else if (l.multiple)
+        n.createdOptions.length = i.value;
+      else {
+        const t = d.value;
+        n.createdOptions.length = 0, t && t.created && n.createdOptions.push(t);
       }
-    }
   }
-  function removeNewOption(option) {
-    if (!enableAllowCreateMode.value || !option || !option.created || option.created && props.reserveKeyword && states.inputValue === getLabel(option)) {
+  function s(e) {
+    if (!a.value || !e || !e.created || e.created && l.reserveKeyword && n.inputValue === r(e))
       return;
-    }
-    const idx = states.createdOptions.findIndex(
-      (it) => getValue(it) === getValue(option)
+    const t = n.createdOptions.findIndex(
+      (o) => u(o) === u(e)
     );
-    if (~idx) {
-      states.createdOptions.splice(idx, 1);
-      createOptionCount.value--;
-    }
+    ~t && (n.createdOptions.splice(t, 1), i.value--);
   }
-  function clearAllNewOption() {
-    if (enableAllowCreateMode.value) {
-      states.createdOptions.length = 0;
-      createOptionCount.value = 0;
-    }
+  function h() {
+    a.value && (n.createdOptions.length = 0, i.value = 0);
   }
   return {
-    createNewOption,
-    removeNewOption,
-    selectNewOption,
-    clearAllNewOption
+    createNewOption: p,
+    removeNewOption: s,
+    selectNewOption: v,
+    clearAllNewOption: h
   };
 }
 export {
-  useAllowCreate
+  x as useAllowCreate
 };

package/es/components/select/useOption.js

@@ -1,17 +1,13 @@
-function useOption(props, { emit }) {
+function t(e, { emit: i }) {
   return {
     hoverItem: () => {
-      if (!props.disabled) {
-        emit("hover", props.index);
-      }
+      e.disabled || i("hover", e.index);
     },
     selectOptionClick: () => {
-      if (!props.disabled) {
-        emit("select", props.item, props.index);
-      }
+      e.disabled || i("select", e.item, e.index);
     }
   };
 }
 export {
-  useOption
+  t as useOption
 };

package/es/components/select/useProps.js

@@ -1,26 +1,22 @@
-import { computed } from "vue";
-import { get } from "lodash-es";
-const defaultProps = {
+import { computed as a } from "vue";
+import { get as o } from "lodash-es";
+const s = {
   label: "label",
   value: "value",
   disabled: "disabled",
   options: "options"
 };
-function useProps(props) {
-  const aliasProps = computed(() => ({ ...defaultProps, ...props.props }));
-  const getLabel = (option) => get(option, aliasProps.value.label);
-  const getValue = (option) => get(option, aliasProps.value.value);
-  const getDisabled = (option) => get(option, aliasProps.value.disabled);
-  const getOptions = (option) => get(option, aliasProps.value.options);
+function d(l) {
+  const t = a(() => ({ ...s, ...l.props }));
   return {
-    aliasProps,
-    getLabel,
-    getValue,
-    getDisabled,
-    getOptions
+    aliasProps: t,
+    getLabel: (e) => o(e, t.value.label),
+    getValue: (e) => o(e, t.value.value),
+    getDisabled: (e) => o(e, t.value.disabled),
+    getOptions: (e) => o(e, t.value.options)
   };
 }
 export {
-  defaultProps,
-  useProps
+  s as defaultProps,
+  d as useProps
 };