vft 0.0.375 → 0.0.376

package/es/components/skeleton/index.js

@@ -2,16 +2,15 @@ import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "vue";
-import { withInstall, withNoopInstall } from "../../utils/vue/install.js";
+import { withInstall as o, withNoopInstall as m } from "../../utils/vue/install.js";
 import "lodash-es";
-import _sfc_main$1 from "./skeleton.vue2.js";
-import _sfc_main from "./skeleton-item.vue2.js";
-const VftSkeleton = withInstall(_sfc_main$1, {
-  SkeletonItem: _sfc_main
-});
-const VftSkeletonItem = withNoopInstall(_sfc_main);
+import i from "./skeleton.vue2.js";
+import t from "./skeleton-item.vue2.js";
+const c = o(i, {
+  SkeletonItem: t
+}), I = m(t);
 export {
-  VftSkeleton,
-  VftSkeletonItem,
-  VftSkeleton as default
+  c as VftSkeleton,
+  I as VftSkeletonItem,
+  c as default
 };

package/es/components/skeleton/skeleton-item.vue.js

@@ -1,4 +1,4 @@
-import _sfc_main from "./skeleton-item.vue2.js";
+import f from "./skeleton-item.vue2.js";
 export {
-  _sfc_main as default
+  f as default
 };

package/es/components/skeleton/skeleton-item.vue2.js

@@ -1,39 +1,35 @@
-import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, unref, createBlock, createCommentVNode, normalizeProps, mergeProps } from "vue";
-import { VftIcon } from "../icon/index.js";
+import { defineComponent as n, computed as a, createElementBlock as c, openBlock as r, normalizeClass as p, unref as e, createBlock as s, createCommentVNode as l, normalizeProps as f, mergeProps as u } from "vue";
+import { VftIcon as d } from "../icon/index.js";
 import "@vueuse/core";
-import { singleAttrToObj } from "@vft/utils";
+import { singleAttrToObj as _ } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useNamespace } from "../../hooks/use-namespace/index.js";
+import { useNamespace as k } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-const __default__ = defineComponent({
+const g = n({
   name: "VftSkeletonItem"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+}), x = /* @__PURE__ */ n({
+  ...g,
   props: {
     variant: { default: "text" },
     imgIcon: {}
   },
-  setup(__props) {
-    const _icon = computed(
-      () => singleAttrToObj(__props.imgIcon, "icon", {
+  setup(i) {
+    const m = a(
+      () => _(i.imgIcon, "icon", {
         size: 20,
         icon: "icon-picture-filled"
       })
-    );
-    const ns = useNamespace("skeleton");
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([unref(ns).e("item"), unref(ns).e(_ctx.variant)])
-      }, [
-        _ctx.variant === "image" ? (openBlock(), createBlock(unref(VftIcon), normalizeProps(mergeProps({ key: 0 }, _icon.value)), null, 16)) : createCommentVNode("", true)
-      ], 2);
-    };
+    ), o = k("skeleton");
+    return (t, v) => (r(), c("div", {
+      class: p([e(o).e("item"), e(o).e(t.variant)])
+    }, [
+      t.variant === "image" ? (r(), s(e(d), f(u({ key: 0 }, m.value)), null, 16)) : l("", !0)
+    ], 2));
   }
 });
 export {
-  _sfc_main as default
+  x as default
 };

package/es/components/skeleton/skeleton.vue.js

@@ -1,4 +1,4 @@
-import _sfc_main from "./skeleton.vue2.js";
+import f from "./skeleton.vue2.js";
 export {
-  _sfc_main as default
+  f as default
 };

package/es/components/skeleton/skeleton.vue2.js

@@ -1,65 +1,56 @@
-import { defineComponent, computed, createElementBlock, renderSlot, unref, openBlock, mergeProps, Fragment, renderList, createCommentVNode, createVNode, normalizeClass, createBlock, normalizeProps } from "vue";
+import { defineComponent as k, computed as y, createElementBlock as a, renderSlot as p, unref as t, openBlock as o, mergeProps as u, Fragment as s, renderList as d, createCommentVNode as h, createVNode as B, normalizeClass as f, createBlock as $, normalizeProps as v } 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 w } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
-import { useThrottleRender } from "../../hooks/use-throttle-render/index.js";
+import { useThrottleRender as C } from "../../hooks/use-throttle-render/index.js";
 import "../../hooks/use-z-index/index.js";
-import _sfc_main$1 from "./skeleton-item.vue2.js";
-const __default__ = defineComponent({
+import c from "./skeleton-item.vue2.js";
+const N = k({
   name: "vft-skeleton"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+}), A = /* @__PURE__ */ k({
+  ...N,
   props: {
-    animated: { type: Boolean, default: false },
+    animated: { type: Boolean, default: !1 },
     count: { default: 1 },
     rows: { default: 3 },
-    loading: { type: Boolean, default: true },
+    loading: { type: Boolean, default: !0 },
     throttle: {}
   },
-  setup(__props, { expose: __expose }) {
-    const ns = useNamespace("skeleton");
-    const uiLoading = useThrottleRender(
-      computed(() => __props.loading),
-      __props.throttle
+  setup(n, { expose: g }) {
+    const r = w("skeleton"), l = C(
+      y(() => n.loading),
+      n.throttle
     );
-    __expose({
+    return g({
       /** @description loading state */
-      uiLoading
-    });
-    return (_ctx, _cache) => {
-      return unref(uiLoading) ? (openBlock(), createElementBlock("div", mergeProps({
-        key: 0,
-        class: [unref(ns).b(), unref(ns).is("animated", _ctx.animated)]
-      }, _ctx.$attrs), [
-        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.count, (i) => {
-          return openBlock(), createElementBlock(Fragment, { key: i }, [
-            _ctx.loading ? renderSlot(_ctx.$slots, "template", { key: i }, () => [
-              createVNode(_sfc_main$1, {
-                class: normalizeClass(unref(ns).is("first")),
-                variant: "p"
-              }, null, 8, ["class"]),
-              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.rows, (item) => {
-                return openBlock(), createBlock(_sfc_main$1, {
-                  key: item,
-                  class: normalizeClass([
-                    unref(ns).e("paragraph"),
-                    unref(ns).is("last", item === _ctx.rows && _ctx.rows > 1)
-                  ]),
-                  variant: "p"
-                }, null, 8, ["class"]);
-              }), 128))
-            ]) : createCommentVNode("", true)
-          ], 64);
-        }), 128))
-      ], 16)) : renderSlot(_ctx.$slots, "default", normalizeProps(mergeProps({ key: 1 }, _ctx.$attrs)));
-    };
+      uiLoading: l
+    }), (e, z) => t(l) ? (o(), a("div", u({
+      key: 0,
+      class: [t(r).b(), t(r).is("animated", e.animated)]
+    }, e.$attrs), [
+      (o(!0), a(s, null, d(e.count, (m) => (o(), a(s, { key: m }, [
+        e.loading ? p(e.$slots, "template", { key: m }, () => [
+          B(c, {
+            class: f(t(r).is("first")),
+            variant: "p"
+          }, null, 8, ["class"]),
+          (o(!0), a(s, null, d(e.rows, (i) => (o(), $(c, {
+            key: i,
+            class: f([
+              t(r).e("paragraph"),
+              t(r).is("last", i === e.rows && e.rows > 1)
+            ]),
+            variant: "p"
+          }, null, 8, ["class"]))), 128))
+        ]) : h("", !0)
+      ], 64))), 128))
+    ], 16)) : p(e.$slots, "default", v(u({ key: 1 }, e.$attrs)));
   }
 });
 export {
-  _sfc_main as default
+  A as default
 };

package/es/components/slider/button.vue.js

@@ -1,4 +1,4 @@
-import _sfc_main from "./button.vue2.js";
+import f from "./button.vue2.js";
 export {
-  _sfc_main as default
+  f as default
 };

package/es/components/slider/button.vue2.js

@@ -1,22 +1,20 @@
-import { defineComponent, reactive, getCurrentInstance, toRefs, createElementBlock, openBlock, unref, normalizeStyle, normalizeClass, createVNode, withCtx, createElementVNode, toDisplayString } from "vue";
+import { defineComponent as v, reactive as T, getCurrentInstance as x, toRefs as P, createElementBlock as z, openBlock as K, unref as t, normalizeStyle as L, normalizeClass as f, createVNode as X, withCtx as g, createElementVNode as b, toDisplayString as Y } from "vue";
 import "@popperjs/core";
-import { isNumber } from "@vft/utils";
-import { VftTooltip } from "../tooltip/index.js";
-import { UPDATE_MODEL_EVENT } from "../../constants/event.js";
+import { isNumber as A } from "@vft/utils";
+import { VftTooltip as F } from "../tooltip/index.js";
+import { UPDATE_MODEL_EVENT as I } from "../../constants/event.js";
 import "@vueuse/core";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useNamespace } from "../../hooks/use-namespace/index.js";
+import { useNamespace as O } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "../../hooks/use-z-index/index.js";
 import "../form/index.js";
-import { useSliderButton } from "./composables/use-slider-button.js";
-const _hoisted_1 = ["tabindex"];
-const __default__ = defineComponent({
+import { useSliderButton as R } from "./composables/use-slider-button.js";
+const U = ["tabindex"], j = v({
   name: "VftSliderButton"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+}), nt = /* @__PURE__ */ v({
+  ...j,
   props: {
     modelValue: { default: 0 },
     vertical: { type: Boolean },
@@ -24,93 +22,85 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     placement: { default: "top" }
   },
   emits: {
-    [UPDATE_MODEL_EVENT]: (value) => isNumber(value)
+    [I]: (i) => A(i)
   },
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const emit = __emit;
-    const ns = useNamespace("slider");
-    const initData = reactive({
-      hovering: false,
-      dragging: false,
-      isClick: false,
+  setup(i, { expose: V, emit: w }) {
+    const y = w, m = O("slider"), u = T({
+      hovering: !1,
+      dragging: !1,
+      isClick: !1,
       startX: 0,
       currentX: 0,
       startY: 0,
       currentY: 0,
       startPosition: 0,
       newPosition: 0,
-      oldValue: __props.modelValue
-    });
-    const vm = getCurrentInstance();
-    const {
-      disabled,
-      button,
-      tooltip,
-      showTooltip,
-      tooltipVisible,
-      wrapperStyle,
-      formatValue,
-      handleMouseEnter,
-      handleMouseLeave,
-      onButtonDown,
-      onKeyDown,
-      setPosition
-    } = useSliderButton(vm.props, initData, emit);
-    const { hovering, dragging } = toRefs(initData);
-    __expose({
-      onButtonDown,
-      onKeyDown,
-      setPosition,
-      hovering,
-      dragging
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        ref_key: "button",
-        ref: button,
-        class: normalizeClass([unref(ns).e("button-wrapper"), { hover: unref(hovering), dragging: unref(dragging) }]),
-        style: normalizeStyle(unref(wrapperStyle)),
-        tabindex: unref(disabled) ? -1 : 0,
-        onMouseenter: _cache[0] || (_cache[0] = //@ts-ignore
-        (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
-        onMouseleave: _cache[1] || (_cache[1] = //@ts-ignore
-        (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args)),
-        onMousedown: _cache[2] || (_cache[2] = //@ts-ignore
-        (...args) => unref(onButtonDown) && unref(onButtonDown)(...args)),
-        onTouchstart: _cache[3] || (_cache[3] = //@ts-ignore
-        (...args) => unref(onButtonDown) && unref(onButtonDown)(...args)),
-        onFocus: _cache[4] || (_cache[4] = //@ts-ignore
-        (...args) => unref(handleMouseEnter) && unref(handleMouseEnter)(...args)),
-        onBlur: _cache[5] || (_cache[5] = //@ts-ignore
-        (...args) => unref(handleMouseLeave) && unref(handleMouseLeave)(...args)),
-        onKeydown: _cache[6] || (_cache[6] = //@ts-ignore
-        (...args) => unref(onKeyDown) && unref(onKeyDown)(...args))
-      }, [
-        createVNode(unref(VftTooltip), {
-          ref_key: "tooltip",
-          ref: tooltip,
-          visible: unref(tooltipVisible),
-          placement: _ctx.placement,
-          "fallback-placements": ["top", "bottom", "right", "left"],
-          "stop-popper-mouse-event": false,
-          "popper-class": _ctx.tooltipClass,
-          disabled: !unref(showTooltip),
-          persistent: ""
-        }, {
-          content: withCtx(() => [
-            createElementVNode("span", null, toDisplayString(unref(formatValue)), 1)
-          ]),
-          default: withCtx(() => [
-            createElementVNode("div", {
-              class: normalizeClass([unref(ns).e("button"), { hover: unref(hovering), dragging: unref(dragging) }])
-            }, null, 2)
-          ]),
-          _: 1
-        }, 8, ["visible", "placement", "popper-class", "disabled"])
-      ], 46, _hoisted_1);
-    };
+      oldValue: i.modelValue
+    }), c = x(), {
+      disabled: B,
+      button: C,
+      tooltip: E,
+      showTooltip: k,
+      tooltipVisible: D,
+      wrapperStyle: M,
+      formatValue: N,
+      handleMouseEnter: r,
+      handleMouseLeave: s,
+      onButtonDown: n,
+      onKeyDown: l,
+      setPosition: S
+    } = R(c.props, u, y), { hovering: p, dragging: a } = P(u);
+    return V({
+      onButtonDown: n,
+      onKeyDown: l,
+      setPosition: S,
+      hovering: p,
+      dragging: a
+    }), (d, e) => (K(), z("div", {
+      ref_key: "button",
+      ref: C,
+      class: f([t(m).e("button-wrapper"), { hover: t(p), dragging: t(a) }]),
+      style: L(t(M)),
+      tabindex: t(B) ? -1 : 0,
+      onMouseenter: e[0] || (e[0] = //@ts-ignore
+      (...o) => t(r) && t(r)(...o)),
+      onMouseleave: e[1] || (e[1] = //@ts-ignore
+      (...o) => t(s) && t(s)(...o)),
+      onMousedown: e[2] || (e[2] = //@ts-ignore
+      (...o) => t(n) && t(n)(...o)),
+      onTouchstart: e[3] || (e[3] = //@ts-ignore
+      (...o) => t(n) && t(n)(...o)),
+      onFocus: e[4] || (e[4] = //@ts-ignore
+      (...o) => t(r) && t(r)(...o)),
+      onBlur: e[5] || (e[5] = //@ts-ignore
+      (...o) => t(s) && t(s)(...o)),
+      onKeydown: e[6] || (e[6] = //@ts-ignore
+      (...o) => t(l) && t(l)(...o))
+    }, [
+      X(t(F), {
+        ref_key: "tooltip",
+        ref: E,
+        visible: t(D),
+        placement: d.placement,
+        "fallback-placements": ["top", "bottom", "right", "left"],
+        "stop-popper-mouse-event": !1,
+        "popper-class": d.tooltipClass,
+        disabled: !t(k),
+        persistent: ""
+      }, {
+        content: g(() => [
+          b("span", null, Y(t(N)), 1)
+        ]),
+        default: g(() => [
+          b("div", {
+            class: f([t(m).e("button"), { hover: t(p), dragging: t(a) }])
+          }, null, 2)
+        ]),
+        _: 1
+      }, 8, ["visible", "placement", "popper-class", "disabled"])
+    ], 46, U));
   }
 });
 export {
-  _sfc_main as default
+  nt as default
 };

package/es/components/slider/composables/index.js

@@ -1,14 +1,14 @@
-import { useLifecycle } from "./use-lifecycle.js";
-import { useMarks } from "./use-marks.js";
-import { useSlide } from "./use-slide.js";
-import { useSliderButton } from "./use-slider-button.js";
-import { useStops } from "./use-stops.js";
-import { useWatch } from "./use-watch.js";
+import { useLifecycle as r } from "./use-lifecycle.js";
+import { useMarks as s } from "./use-marks.js";
+import { useSlide as p } from "./use-slide.js";
+import { useSliderButton as m } from "./use-slider-button.js";
+import { useStops as c } from "./use-stops.js";
+import { useWatch as l } from "./use-watch.js";
 export {
-  useLifecycle,
-  useMarks,
-  useSlide,
-  useSliderButton,
-  useStops,
-  useWatch
+  r as useLifecycle,
+  s as useMarks,
+  p as useSlide,
+  m as useSliderButton,
+  c as useStops,
+  l as useWatch
 };

package/es/components/slider/composables/use-lifecycle.js

@@ -1,36 +1,16 @@
-import { useEventListener } from "@vueuse/core";
-import { ref, onMounted, nextTick } from "vue";
-const useLifecycle = (props, initData, resetSize) => {
-  const sliderWrapper = ref();
-  onMounted(async () => {
-    if (props.range) {
-      if (Array.isArray(props.modelValue)) {
-        initData.firstValue = Math.max(props.min, props.modelValue[0]);
-        initData.secondValue = Math.min(props.max, props.modelValue[1]);
-      } else {
-        initData.firstValue = props.min;
-        initData.secondValue = props.max;
-      }
-      initData.oldValue = [initData.firstValue, initData.secondValue];
-    } else {
-      if (typeof props.modelValue !== "number" || Number.isNaN(props.modelValue)) {
-        initData.firstValue = props.min;
-      } else {
-        initData.firstValue = Math.min(
-          props.max,
-          Math.max(props.min, props.modelValue)
-        );
-      }
-      initData.oldValue = initData.firstValue;
-    }
-    useEventListener(window, "resize", resetSize);
-    await nextTick();
-    resetSize();
-  });
-  return {
-    sliderWrapper
+import { useEventListener as V } from "@vueuse/core";
+import { ref as a, onMounted as d, nextTick as f } from "vue";
+const c = (e, l, m) => {
+  const u = a();
+  return d(async () => {
+    e.range ? (Array.isArray(e.modelValue) ? (l.firstValue = Math.max(e.min, e.modelValue[0]), l.secondValue = Math.min(e.max, e.modelValue[1])) : (l.firstValue = e.min, l.secondValue = e.max), l.oldValue = [l.firstValue, l.secondValue]) : (typeof e.modelValue != "number" || Number.isNaN(e.modelValue) ? l.firstValue = e.min : l.firstValue = Math.min(
+      e.max,
+      Math.max(e.min, e.modelValue)
+    ), l.oldValue = l.firstValue), V(window, "resize", m), await f(), m();
+  }), {
+    sliderWrapper: u
   };
 };
 export {
-  useLifecycle
+  c as useLifecycle
 };

package/es/components/slider/composables/use-marks.js

@@ -1,19 +1,11 @@
-import { computed } from "vue";
-const useMarks = (props) => {
-  return computed(() => {
-    if (!props.marks) {
-      return [];
-    }
-    const marksKeys = Object.keys(props.marks);
-    return marksKeys.map(Number.parseFloat).sort((a, b) => a - b).filter((point) => point <= props.max && point >= props.min).map(
-      (point) => ({
-        point,
-        position: (point - props.min) * 100 / (props.max - props.min),
-        mark: props.marks[point]
-      })
-    );
-  });
-};
+import { computed as r } from "vue";
+const s = (m) => r(() => m.marks ? Object.keys(m.marks).map(Number.parseFloat).sort((a, e) => a - e).filter((a) => a <= m.max && a >= m.min).map(
+  (a) => ({
+    point: a,
+    position: (a - m.min) * 100 / (m.max - m.min),
+    mark: m.marks[a]
+  })
+) : []);
 export {
-  useMarks
+  s as useMarks
 };