vft 0.0.375 → 0.0.376

package/es/components/popper/utils.js

@@ -1,26 +1,23 @@
-import { isClient, unrefElement } from "@vueuse/core";
-const buildPopperOptions = (props, modifiers = []) => {
-  const { placement, strategy, popperOptions } = props;
-  const options = {
-    placement,
-    strategy,
-    ...popperOptions,
-    modifiers: [...genModifiers(props), ...modifiers]
+import { isClient as s, unrefElement as f } from "@vueuse/core";
+const m = (e, t = []) => {
+  const { placement: o, strategy: n, popperOptions: i } = e, r = {
+    placement: o,
+    strategy: n,
+    ...i,
+    modifiers: [...p(e), ...t]
   };
-  deriveExtraModifiers(options, popperOptions?.modifiers);
-  return options;
+  return a(r, i?.modifiers), r;
+}, c = (e) => {
+  if (s)
+    return f(e);
 };
-const unwrapMeasurableEl = ($el) => {
-  if (!isClient) return;
-  return unrefElement($el);
-};
-function genModifiers(options) {
-  const { offset, gpuAcceleration, fallbackPlacements } = options;
+function p(e) {
+  const { offset: t, gpuAcceleration: o, fallbackPlacements: n } = e;
   return [
     {
       name: "offset",
       options: {
-        offset: [0, offset ?? 12]
+        offset: [0, t ?? 12]
       }
     },
     {
@@ -38,23 +35,21 @@ function genModifiers(options) {
       name: "flip",
       options: {
         padding: 5,
-        fallbackPlacements
+        fallbackPlacements: n
       }
     },
     {
       name: "computeStyles",
       options: {
-        gpuAcceleration
+        gpuAcceleration: o
       }
     }
   ];
 }
-function deriveExtraModifiers(options, modifiers) {
-  if (modifiers) {
-    options.modifiers = [...options.modifiers, ...modifiers ?? []];
-  }
+function a(e, t) {
+  t && (e.modifiers = [...e.modifiers, ...t ?? []]);
 }
 export {
-  buildPopperOptions,
-  unwrapMeasurableEl
+  m as buildPopperOptions,
+  c as unwrapMeasurableEl
 };

package/es/components/progress/index.js

@@ -2,11 +2,11 @@ import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "vue";
-import { withInstall } from "../../utils/vue/install.js";
+import { withInstall as t } from "../../utils/vue/install.js";
 import "lodash-es";
-import _sfc_main from "./progress.vue2.js";
-const VftProgress = withInstall(_sfc_main);
+import o from "./progress.vue2.js";
+const e = t(o);
 export {
-  VftProgress,
-  VftProgress as default
+  e as VftProgress,
+  e as default
 };

package/es/components/progress/progress.vue.js

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

package/es/components/progress/progress.vue2.js

@@ -1,220 +1,166 @@
-import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, createElementVNode, normalizeStyle, renderSlot, toDisplayString, createBlock, normalizeProps, mergeProps } from "vue";
-import { isFunction, isString } from "@vft/utils";
-import { VftIcon } from "../icon/index.js";
+import { defineComponent as T, computed as s, createElementBlock as i, openBlock as l, normalizeClass as n, unref as a, createCommentVNode as y, createElementVNode as f, normalizeStyle as u, renderSlot as C, toDisplayString as D, createBlock as x, normalizeProps as A, mergeProps as L } from "vue";
+import { isFunction as M, isString as I } from "@vft/utils";
+import { VftIcon as E } from "../icon/index.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 "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-const _hoisted_1 = ["aria-valuenow"];
-const _hoisted_2 = { viewBox: "0 0 100 100" };
-const _hoisted_3 = ["d", "stroke", "stroke-width"];
-const _hoisted_4 = ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"];
-const _hoisted_5 = { key: 0 };
-const __default__ = defineComponent({
+const R = ["aria-valuenow"], U = { viewBox: "0 0 100 100" }, j = ["d", "stroke", "stroke-width"], q = ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"], G = { key: 0 }, H = T({
   name: "vft-progress"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+}), re = /* @__PURE__ */ T({
+  ...H,
   props: {
     type: { default: "line" },
     percentage: { default: 0 },
     status: { default: "" },
-    indeterminate: { type: Boolean, default: false },
+    indeterminate: { type: Boolean, default: !1 },
     duration: { default: 3 },
     strokeWidth: { default: 6 },
     strokeLinecap: { default: "round" },
-    textInside: { type: Boolean, default: false },
+    textInside: { type: Boolean, default: !1 },
     width: { default: 126 },
-    showText: { type: Boolean, default: true },
+    showText: { type: Boolean, default: !0 },
     color: { type: [String, Array, Function], default: "" },
-    striped: { type: Boolean, default: false },
-    stripedFlow: { type: Boolean, default: false },
-    format: { type: Function, default: (percentage) => `${percentage}%` }
+    striped: { type: Boolean, default: !1 },
+    stripedFlow: { type: Boolean, default: !1 },
+    format: { type: Function, default: (t) => `${t}%` }
   },
-  setup(__props) {
-    const ns = useNamespace("progress");
-    const STATUS_COLOR_MAP = {
+  setup(t) {
+    const r = O("progress"), p = {
       success: "#13ce66",
       exception: "#ff4949",
       warning: "#e6a23c",
       default: "#20a0ff"
-    };
-    const barStyle = computed(() => ({
-      width: `${__props.percentage}%`,
-      animationDuration: `${__props.duration}s`,
-      backgroundColor: getCurrentColor(__props.percentage)
-    }));
-    const relativeStrokeWidth = computed(
-      () => (__props.strokeWidth / __props.width * 100).toFixed(1)
-    );
-    const radius = computed(() => {
-      if (["circle", "dashboard"].includes(__props.type)) {
-        return Number.parseInt(
-          `${50 - Number.parseFloat(relativeStrokeWidth.value) / 2}`,
-          10
-        );
-      }
-      return 0;
-    });
-    const trackPath = computed(() => {
-      const r = radius.value;
-      const isDashboard = __props.type === "dashboard";
+    }, F = s(() => ({
+      width: `${t.percentage}%`,
+      animationDuration: `${t.duration}s`,
+      backgroundColor: B(t.percentage)
+    })), h = s(
+      () => (t.strokeWidth / t.width * 100).toFixed(1)
+    ), g = s(() => ["circle", "dashboard"].includes(t.type) ? Number.parseInt(
+      `${50 - Number.parseFloat(h.value) / 2}`,
+      10
+    ) : 0), $ = s(() => {
+      const e = g.value, o = t.type === "dashboard";
       return `
           M 50 50
-          m 0 ${isDashboard ? "" : "-"}${r}
-          a ${r} ${r} 0 1 1 0 ${isDashboard ? "-" : ""}${r * 2}
-          a ${r} ${r} 0 1 1 0 ${isDashboard ? "" : "-"}${r * 2}
+          m 0 ${o ? "" : "-"}${e}
+          a ${e} ${e} 0 1 1 0 ${o ? "-" : ""}${e * 2}
+          a ${e} ${e} 0 1 1 0 ${o ? "" : "-"}${e * 2}
           `;
-    });
-    const perimeter = computed(() => 2 * Math.PI * radius.value);
-    const rate = computed(() => __props.type === "dashboard" ? 0.75 : 1);
-    const strokeDashoffset = computed(() => {
-      const offset = -1 * perimeter.value * (1 - rate.value) / 2;
-      return `${offset}px`;
-    });
-    const trailPathStyle = computed(() => ({
-      strokeDasharray: `${perimeter.value * rate.value}px, ${perimeter.value}px`,
-      strokeDashoffset: strokeDashoffset.value
-    }));
-    const circlePathStyle = computed(() => ({
-      strokeDasharray: `${perimeter.value * rate.value * (__props.percentage / 100)}px, ${perimeter.value}px`,
-      strokeDashoffset: strokeDashoffset.value,
+    }), c = s(() => 2 * Math.PI * g.value), m = s(() => t.type === "dashboard" ? 0.75 : 1), b = s(() => `${-1 * c.value * (1 - m.value) / 2}px`), P = s(() => ({
+      strokeDasharray: `${c.value * m.value}px, ${c.value}px`,
+      strokeDashoffset: b.value
+    })), N = s(() => ({
+      strokeDasharray: `${c.value * m.value * (t.percentage / 100)}px, ${c.value}px`,
+      strokeDashoffset: b.value,
       transition: "stroke-dasharray 0.6s ease 0s, stroke 0.6s ease, opacity ease 0.6s"
-    }));
-    const stroke = computed(() => {
-      let ret;
-      if (__props.color) {
-        ret = getCurrentColor(__props.percentage);
-      } else {
-        ret = STATUS_COLOR_MAP[__props.status] || STATUS_COLOR_MAP.default;
-      }
-      return ret;
-    });
-    const statusIcon = computed(() => {
-      if (__props.status === "warning") {
-        return "icon-warning-filled";
-      }
-      if (__props.type === "line") {
-        return __props.status === "success" ? "icon-circle-check" : "icon-circle-close";
-      } else {
-        return __props.status === "success" ? "icon-check" : "icon-close";
-      }
-    });
-    const progressTextSize = computed(() => {
-      return __props.type === "line" ? 12 + __props.strokeWidth * 0.4 : __props.width * 0.111111 + 2;
-    });
-    const content = computed(() => __props.format(__props.percentage));
-    function getColors(_color) {
-      const span = 100 / _color.length;
-      const seriesColors = _color.map((seriesColor, index) => {
-        if (isString(seriesColor)) {
-          return {
-            color: seriesColor,
-            percentage: (index + 1) * span
-          };
-        }
-        return seriesColor;
-      });
-      return seriesColors.sort((a, b) => a.percentage - b.percentage);
+    })), z = s(() => {
+      let e;
+      return t.color ? e = B(t.percentage) : e = p[t.status] || p.default, e;
+    }), w = s(() => t.status === "warning" ? "icon-warning-filled" : t.type === "line" ? t.status === "success" ? "icon-circle-check" : "icon-circle-close" : t.status === "success" ? "icon-check" : "icon-close"), W = s(() => t.type === "line" ? 12 + t.strokeWidth * 0.4 : t.width * 0.111111 + 2), S = s(() => t.format(t.percentage));
+    function V(e) {
+      const o = 100 / e.length;
+      return e.map((d, k) => I(d) ? {
+        color: d,
+        percentage: (k + 1) * o
+      } : d).sort((d, k) => d.percentage - k.percentage);
     }
-    const getCurrentColor = (percentage) => {
-      if (isFunction(__props.color)) {
-        return __props.color(percentage);
-      } else if (isString(__props.color)) {
-        return __props.color;
-      } else {
-        const colors = getColors(__props.color);
-        for (const _color of colors) {
-          if (_color.percentage > percentage) return _color.color;
-        }
-        return colors[colors.length - 1]?.color;
+    const B = (e) => {
+      if (M(t.color))
+        return t.color(e);
+      if (I(t.color))
+        return t.color;
+      {
+        const o = V(t.color);
+        for (const v of o)
+          if (v.percentage > e) return v.color;
+        return o[o.length - 1]?.color;
       }
     };
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          unref(ns).b(),
-          unref(ns).m(_ctx.type),
-          unref(ns).is(_ctx.status),
-          {
-            [unref(ns).m("without-text")]: !_ctx.showText,
-            [unref(ns).m("text-inside")]: _ctx.textInside
-          }
-        ]),
-        role: "progressbar",
-        "aria-valuenow": _ctx.percentage,
-        "aria-valuemin": "0",
-        "aria-valuemax": "100"
+    return (e, o) => (l(), i("div", {
+      class: n([
+        a(r).b(),
+        a(r).m(e.type),
+        a(r).is(e.status),
+        {
+          [a(r).m("without-text")]: !e.showText,
+          [a(r).m("text-inside")]: e.textInside
+        }
+      ]),
+      role: "progressbar",
+      "aria-valuenow": e.percentage,
+      "aria-valuemin": "0",
+      "aria-valuemax": "100"
+    }, [
+      e.type === "line" ? (l(), i("div", {
+        key: 0,
+        class: n(a(r).b("bar"))
       }, [
-        _ctx.type === "line" ? (openBlock(), createElementBlock("div", {
-          key: 0,
-          class: normalizeClass(unref(ns).b("bar"))
+        f("div", {
+          class: n(a(r).be("bar", "outer")),
+          style: u({ height: `${e.strokeWidth}px` })
         }, [
-          createElementVNode("div", {
-            class: normalizeClass(unref(ns).be("bar", "outer")),
-            style: normalizeStyle({ height: `${_ctx.strokeWidth}px` })
+          f("div", {
+            class: n([
+              a(r).be("bar", "inner"),
+              { [a(r).bem("bar", "inner", "indeterminate")]: e.indeterminate },
+              { [a(r).bem("bar", "inner", "striped")]: e.striped },
+              { [a(r).bem("bar", "inner", "striped-flow")]: e.stripedFlow }
+            ]),
+            style: u(F.value)
           }, [
-            createElementVNode("div", {
-              class: normalizeClass([
-                unref(ns).be("bar", "inner"),
-                { [unref(ns).bem("bar", "inner", "indeterminate")]: _ctx.indeterminate },
-                { [unref(ns).bem("bar", "inner", "striped")]: _ctx.striped },
-                { [unref(ns).bem("bar", "inner", "striped-flow")]: _ctx.stripedFlow }
-              ]),
-              style: normalizeStyle(barStyle.value)
+            (e.showText || e.$slots.default) && e.textInside ? (l(), i("div", {
+              key: 0,
+              class: n(a(r).be("bar", "innerText"))
             }, [
-              (_ctx.showText || _ctx.$slots.default) && _ctx.textInside ? (openBlock(), createElementBlock("div", {
-                key: 0,
-                class: normalizeClass(unref(ns).be("bar", "innerText"))
-              }, [
-                renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
-                  createElementVNode("span", null, toDisplayString(content.value), 1)
-                ])
-              ], 2)) : createCommentVNode("", true)
-            ], 6)
+              C(e.$slots, "default", { percentage: e.percentage }, () => [
+                f("span", null, D(S.value), 1)
+              ])
+            ], 2)) : y("", !0)
           ], 6)
-        ], 2)) : (openBlock(), createElementBlock("div", {
-          key: 1,
-          class: normalizeClass(unref(ns).b("circle")),
-          style: normalizeStyle({ height: `${_ctx.width}px`, width: `${_ctx.width}px` })
-        }, [
-          (openBlock(), createElementBlock("svg", _hoisted_2, [
-            createElementVNode("path", {
-              class: normalizeClass(unref(ns).be("circle", "track")),
-              d: trackPath.value,
-              stroke: `var(${unref(ns).cssVarName("fill-color-light")}, #e5e9f2)`,
-              "stroke-width": relativeStrokeWidth.value,
-              fill: "none",
-              style: normalizeStyle(trailPathStyle.value)
-            }, null, 14, _hoisted_3),
-            createElementVNode("path", {
-              class: normalizeClass(unref(ns).be("circle", "path")),
-              d: trackPath.value,
-              stroke: stroke.value,
-              fill: "none",
-              opacity: _ctx.percentage ? 1 : 0,
-              "stroke-linecap": _ctx.strokeLinecap,
-              "stroke-width": relativeStrokeWidth.value,
-              style: normalizeStyle(circlePathStyle.value)
-            }, null, 14, _hoisted_4)
-          ]))
-        ], 6)),
-        (_ctx.showText || _ctx.$slots.default) && !_ctx.textInside ? (openBlock(), createElementBlock("div", {
-          key: 2,
-          class: normalizeClass(unref(ns).e("text")),
-          style: normalizeStyle({ fontSize: `${progressTextSize.value}px` })
-        }, [
-          renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
-            !_ctx.status ? (openBlock(), createElementBlock("span", _hoisted_5, toDisplayString(content.value), 1)) : statusIcon.value?.icon ? (openBlock(), createBlock(unref(VftIcon), normalizeProps(mergeProps({ key: 1 }, statusIcon.value)), null, 16)) : createCommentVNode("", true)
-          ])
-        ], 6)) : createCommentVNode("", true)
-      ], 10, _hoisted_1);
-    };
+        ], 6)
+      ], 2)) : (l(), i("div", {
+        key: 1,
+        class: n(a(r).b("circle")),
+        style: u({ height: `${e.width}px`, width: `${e.width}px` })
+      }, [
+        (l(), i("svg", U, [
+          f("path", {
+            class: n(a(r).be("circle", "track")),
+            d: $.value,
+            stroke: `var(${a(r).cssVarName("fill-color-light")}, #e5e9f2)`,
+            "stroke-width": h.value,
+            fill: "none",
+            style: u(P.value)
+          }, null, 14, j),
+          f("path", {
+            class: n(a(r).be("circle", "path")),
+            d: $.value,
+            stroke: z.value,
+            fill: "none",
+            opacity: e.percentage ? 1 : 0,
+            "stroke-linecap": e.strokeLinecap,
+            "stroke-width": h.value,
+            style: u(N.value)
+          }, null, 14, q)
+        ]))
+      ], 6)),
+      (e.showText || e.$slots.default) && !e.textInside ? (l(), i("div", {
+        key: 2,
+        class: n(a(r).e("text")),
+        style: u({ fontSize: `${W.value}px` })
+      }, [
+        C(e.$slots, "default", { percentage: e.percentage }, () => [
+          e.status ? w.value?.icon ? (l(), x(a(E), A(L({ key: 1 }, w.value)), null, 16)) : y("", !0) : (l(), i("span", G, D(S.value), 1))
+        ])
+      ], 6)) : y("", !0)
+    ], 10, R));
   }
 });
 export {
-  _sfc_main as default
+  re as default
 };

package/es/components/progress-i/index.js

@@ -2,11 +2,11 @@ import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "vue";
-import { withInstall } from "../../utils/vue/install.js";
+import { withInstall as t } from "../../utils/vue/install.js";
 import "lodash-es";
-import _sfc_main from "./progress-i.vue2.js";
-const VftProgressI = withInstall(_sfc_main);
+import o from "./progress-i.vue2.js";
+const e = t(o);
 export {
-  VftProgressI,
-  VftProgressI as default
+  e as VftProgressI,
+  e as default
 };

package/es/components/progress-i/progress-i.vue.js

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

package/es/components/progress-i/progress-i.vue2.js

@@ -1,13 +1,10 @@
-import { defineComponent, createElementBlock, openBlock } from "vue";
-const _sfc_main = /* @__PURE__ */ defineComponent({
+import { defineComponent as e, createElementBlock as o, openBlock as n } from "vue";
+const p = /* @__PURE__ */ e({
   __name: "progress-i",
-  setup(__props) {
-    console.log(1);
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", null, "1");
-    };
+  setup(r) {
+    return console.log(1), (t, c) => (n(), o("div", null, "1"));
   }
 });
 export {
-  _sfc_main as default
+  p as default
 };

package/es/components/qrcode/drawCanvas.js

@@ -1,31 +1,21 @@
-import { cloneDeep } from "lodash-es";
-import { toCanvas } from "qrcode";
-const renderQrCode = ({
-  canvas,
-  content,
-  width = 0,
-  options: params = {}
+import { cloneDeep as s } from "lodash-es";
+import { toCanvas as t } from "qrcode";
+const f = ({
+  canvas: e,
+  content: r,
+  width: o = 0,
+  options: i = {}
 }) => {
-  const options = cloneDeep(params);
-  options.errorCorrectionLevel = options.errorCorrectionLevel || getErrorCorrectionLevel(content);
-  return getOriginWidth(content, options).then((_width) => {
-    options.scale = width === 0 ? void 0 : width / _width * 4;
-    return toCanvas(canvas, content, options);
-  });
+  const n = s(i);
+  return n.errorCorrectionLevel = n.errorCorrectionLevel || u(r), l(r, n).then((c) => (n.scale = o === 0 ? void 0 : o / c * 4, t(e, r, n)));
 };
-function getOriginWidth(content, options) {
-  const _canvas = document.createElement("canvas");
-  return toCanvas(_canvas, content, options).then(() => _canvas.width);
+function l(e, r) {
+  const o = document.createElement("canvas");
+  return t(o, e, r).then(() => o.width);
 }
-function getErrorCorrectionLevel(content) {
-  if (content.length > 36) {
-    return "M";
-  } else if (content.length > 16) {
-    return "Q";
-  } else {
-    return "H";
-  }
+function u(e) {
+  return e.length > 36 ? "M" : e.length > 16 ? "Q" : "H";
 }
 export {
-  renderQrCode
+  f as renderQrCode
 };