vft 0.0.375 → 0.0.376

package/es/components/container/index.js

@@ -2,28 +2,24 @@ 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 f, withNoopInstall as o } from "../../utils/vue/install.js";
 import "lodash-es";
-import _sfc_main$3 from "./aside.vue2.js";
-import _sfc_main$4 from "./container.vue2.js";
-import _sfc_main$2 from "./footer.vue2.js";
-import _sfc_main$1 from "./header.vue2.js";
-import _sfc_main from "./main.vue2.js";
-const VftContainer = withInstall(_sfc_main$4, {
-  Aside: _sfc_main$3,
-  Footer: _sfc_main$2,
-  Header: _sfc_main$1,
-  Main: _sfc_main
-});
-const VftAside = withNoopInstall(_sfc_main$3);
-const VftFooter = withNoopInstall(_sfc_main$2);
-const VftHeader = withNoopInstall(_sfc_main$1);
-const VftMain = withNoopInstall(_sfc_main);
+import t from "./aside.vue2.js";
+import n from "./container.vue2.js";
+import i from "./footer.vue2.js";
+import r from "./header.vue2.js";
+import m from "./main.vue2.js";
+const w = f(n, {
+  Aside: t,
+  Footer: i,
+  Header: r,
+  Main: m
+}), A = o(t), F = o(i), H = o(r), I = o(m);
 export {
-  VftAside,
-  VftContainer,
-  VftFooter,
-  VftHeader,
-  VftMain,
-  VftContainer as default
+  A as VftAside,
+  w as VftContainer,
+  F as VftFooter,
+  H as VftHeader,
+  I as VftMain,
+  w as default
 };

package/es/components/container/main.vue.js

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

package/es/components/container/main.vue2.js

@@ -1,29 +1,26 @@
-import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, renderSlot } from "vue";
+import { defineComponent as e, createElementBlock as r, openBlock as m, normalizeClass as n, unref as s, renderSlot as a } 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 p } 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 i = e({
   name: "vft-main"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
-  setup(__props) {
-    const ns = useNamespace("main");
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("main", {
-        ref: "testRef",
-        class: normalizeClass(unref(ns).b())
-      }, [
-        renderSlot(_ctx.$slots, "default")
-      ], 2);
-    };
+}), v = /* @__PURE__ */ e({
+  ...i,
+  setup(c) {
+    const t = p("main");
+    return (o, f) => (m(), r("main", {
+      ref: "testRef",
+      class: n(s(t).b())
+    }, [
+      a(o.$slots, "default")
+    ], 2));
   }
 });
 export {
-  _sfc_main as default
+  v as default
 };

package/es/components/context-menu/context-menu.vue.js

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

package/es/components/context-menu/context-menu.vue2.js

@@ -1,120 +1,103 @@
-import { defineComponent, ref, computed, createBlock, openBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, withModifiers, normalizeStyle, unref, createElementBlock, Fragment, renderList, vShow } from "vue";
-import { useTimeoutFn, useClickAway, useEventListener } from "@vft/use";
-import { VftMenuItem } from "../menu/index.js";
+import { defineComponent as p, ref as d, computed as k, createBlock as c, openBlock as r, Transition as C, withCtx as b, withDirectives as g, createElementVNode as m, normalizeClass as z, withModifiers as M, normalizeStyle as $, unref as u, createElementBlock as B, Fragment as E, renderList as S, vShow as F } from "vue";
+import { useTimeoutFn as H, useClickAway as I, useEventListener as f } from "@vft/use";
+import { VftMenuItem as L } from "../menu/index.js";
 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 N } 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 = { class: "vft-sub-menu" };
-const __default__ = defineComponent({
+const R = { class: "vft-sub-menu" }, T = p({
   name: "vft-context-menu"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+}), P = /* @__PURE__ */ p({
+  ...T,
   props: {
     axis: {},
     styles: {},
     width: {},
     items: {}
   },
-  setup(__props) {
-    const ns = useNamespace("context-menu");
-    let contextMenuRef = ref();
-    const getStyle = computed(() => {
-      const { x, y } = __props.axis || { x: 0, y: 0 };
-      const menuHeight = (__props.items || []).length * 40;
-      const menuWidth = __props.width || 0;
-      const body = document.body;
-      const left = body.clientWidth < x + menuWidth ? x - menuWidth : x;
-      const top = body.clientHeight < y + menuHeight ? y - menuHeight : y;
+  setup(o) {
+    const v = N("context-menu");
+    let a = d();
+    const x = k(() => {
+      const { x: t, y: i } = o.axis || { x: 0, y: 0 }, e = (o.items || []).length * 40, l = o.width || 0, s = document.body, w = s.clientWidth < t + l ? t - l : t, y = s.clientHeight < i + e ? i - e : i;
       return {
         zIndex: 3e3,
-        ...__props.styles,
+        ...o.styles,
         position: "fixed",
-        width: `${__props.width}px`,
-        left: `${left + 1}px`,
-        top: `${top + 1}px`
+        width: `${o.width}px`,
+        left: `${w + 1}px`,
+        top: `${y + 1}px`
       };
     });
-    let show = ref(false);
-    useTimeoutFn(() => {
-      show.value = true;
-    }, 0);
-    useClickAway(
-      contextMenuRef,
+    let n = d(!1);
+    H(() => {
+      n.value = !0;
+    }, 0), I(
+      a,
       () => {
-        show.value = false;
+        n.value = !1;
       },
       {
         listenerOptions: {
-          capture: true
+          capture: !0
         }
       }
-    );
-    useEventListener(
+    ), f(
       window,
       "scroll",
       () => {
-        show.value = false;
+        n.value = !1;
       },
       {
-        capture: true
+        capture: !0
       }
-    );
-    useEventListener(
+    ), f(
       window,
       "drag",
       () => {
-        show.value = false;
+        n.value = !1;
       },
       {
-        capture: true
+        capture: !0
       }
     );
-    function handleClick(item) {
-      if (!item?.disabled) {
-        item.handler?.();
-        show.value = false;
-      }
+    function h(t) {
+      t?.disabled || (t.handler?.(), n.value = !1);
     }
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(Transition, { name: "vft-zoom-in-top" }, {
-        default: withCtx(() => [
-          withDirectives(createElementVNode("div", {
-            ref_key: "contextMenuRef",
-            ref: contextMenuRef,
-            style: normalizeStyle(getStyle.value),
-            onClick: _cache[0] || (_cache[0] = withModifiers(() => {
-            }, ["stop"])),
-            class: normalizeClass([unref(ns).b(), "vft-menu"])
-          }, [
-            createElementVNode("div", _hoisted_1, [
-              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.items, (item, index) => {
-                return openBlock(), createBlock(unref(VftMenuItem), {
-                  onClick: ($event) => handleClick(item),
-                  index: index + item.text,
-                  title: item.text,
-                  divider: item.divider,
-                  disabled: item.disabled,
-                  icon: item.iconCfg,
-                  "is-alone-use": "",
-                  key: index
-                }, null, 8, ["onClick", "index", "title", "divider", "disabled", "icon"]);
-              }), 128))
-            ])
-          ], 6), [
-            [vShow, unref(show)]
+    return (t, i) => (r(), c(C, { name: "vft-zoom-in-top" }, {
+      default: b(() => [
+        g(m("div", {
+          ref_key: "contextMenuRef",
+          ref: a,
+          style: $(x.value),
+          onClick: i[0] || (i[0] = M(() => {
+          }, ["stop"])),
+          class: z([u(v).b(), "vft-menu"])
+        }, [
+          m("div", R, [
+            (r(!0), B(E, null, S(t.items, (e, l) => (r(), c(u(L), {
+              onClick: (s) => h(e),
+              index: l + e.text,
+              title: e.text,
+              divider: e.divider,
+              disabled: e.disabled,
+              icon: e.iconCfg,
+              "is-alone-use": "",
+              key: l
+            }, null, 8, ["onClick", "index", "title", "divider", "disabled", "icon"]))), 128))
           ])
-        ]),
-        _: 1
-      });
-    };
+        ], 6), [
+          [F, u(n)]
+        ])
+      ]),
+      _: 1
+    }));
   }
 });
 export {
-  _sfc_main as default
+  P as default
 };

package/es/components/context-menu/createContextMenu.js

@@ -1,58 +1,40 @@
-import { isClient } from "@vft/utils";
-import { createVNode, render } from "vue";
-import _sfc_main from "./context-menu.vue2.js";
-const menuManager = {
+import { isClient as v } from "@vft/utils";
+import { createVNode as a, render as f } from "vue";
+import u from "./context-menu.vue2.js";
+const e = {
   domList: [],
   resolve: () => {
   }
-};
-const createContextMenu = function(options) {
-  const { event } = options || {};
-  event && event?.preventDefault();
-  if (!isClient) {
-    return;
-  }
-  return new Promise((resolve) => {
-    const body = document.body;
-    const container = document.createElement("div");
-    const propsData = {
-      ...options
-    };
-    if (options.event) {
-      propsData.axis = { x: event.clientX, y: event.clientY };
-      delete propsData.event;
-    }
-    const vm = createVNode(_sfc_main, propsData);
-    render(vm, container);
-    const handleClick = function() {
-      menuManager.resolve("");
-    };
-    menuManager.domList.push(container);
-    const remove = function() {
-      menuManager.domList.forEach((dom) => {
-        try {
-          dom && body.removeChild(dom);
-        } catch (error) {
-        }
-      });
-      body.removeEventListener("click", handleClick);
-      body.removeEventListener("scroll", handleClick);
-    };
-    menuManager.resolve = function(arg) {
-      remove();
-      resolve(arg);
-    };
-    remove();
-    body.appendChild(container);
-  });
-};
-const destroyContextMenu = function() {
-  if (menuManager) {
-    menuManager.resolve("");
-    menuManager.domList = [];
-  }
+}, x = function(r) {
+  const { event: t } = r || {};
+  if (t && t?.preventDefault(), !!v)
+    return new Promise((l) => {
+      const n = document.body, c = document.createElement("div"), i = {
+        ...r
+      };
+      r.event && (i.axis = { x: t.clientX, y: t.clientY }, delete i.event);
+      const d = a(u, i);
+      f(d, c);
+      const s = function() {
+        e.resolve("");
+      };
+      e.domList.push(c);
+      const m = function() {
+        e.domList.forEach((o) => {
+          try {
+            o && n.removeChild(o);
+          } catch {
+          }
+        }), n.removeEventListener("click", s), n.removeEventListener("scroll", s);
+      };
+      e.resolve = function(o) {
+        m(), l(o);
+      }, m(), n.appendChild(c);
+    });
+}, y = function() {
+  e && (e.resolve(""), e.domList = []);
 };
 export {
-  createContextMenu,
-  destroyContextMenu
+  x as createContextMenu,
+  y as destroyContextMenu
 };

package/es/components/context-menu/index.js

@@ -1,9 +1,9 @@
-import { createContextMenu, destroyContextMenu } from "./createContextMenu.js";
+import { createContextMenu as n, destroyContextMenu as x } from "./createContextMenu.js";
 import "../icon/index.js";
 import "vue";
-import { useContextMenu } from "./useContextMenu.js";
+import { useContextMenu as p } from "./useContextMenu.js";
 export {
-  createContextMenu,
-  destroyContextMenu,
-  useContextMenu
+  n as createContextMenu,
+  x as destroyContextMenu,
+  p as useContextMenu
 };

package/es/components/context-menu/useContextMenu.js

@@ -1,13 +1,10 @@
-import { getCurrentInstance, onUnmounted } from "vue";
-import { createContextMenu, destroyContextMenu } from "./createContextMenu.js";
-function useContextMenu(authRemove = true) {
-  if (getCurrentInstance() && authRemove) {
-    onUnmounted(() => {
-      destroyContextMenu();
-    });
-  }
-  return [createContextMenu, destroyContextMenu];
+import { getCurrentInstance as n, onUnmounted as o } from "vue";
+import { createContextMenu as r, destroyContextMenu as t } from "./createContextMenu.js";
+function f(e = !0) {
+  return n() && e && o(() => {
+    t();
+  }), [r, t];
 }
 export {
-  useContextMenu
+  f as useContextMenu
 };

package/es/components/countdown/countdown.js

@@ -1,10 +1,10 @@
 import "@vueuse/core";
-import { isNumber } from "@vft/utils";
+import { isNumber as i } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
-import { CHANGE_EVENT } from "../../constants/event.js";
+import { CHANGE_EVENT as o } from "../../constants/event.js";
 import "vue";
-import { buildProps, definePropType } from "../../utils/vue/props/runtime.js";
-const countdownProps = buildProps({
+import { buildProps as e, definePropType as t } from "../../utils/vue/props/runtime.js";
+const l = e({
   /**
    * @description Formatting the countdown display
    */
@@ -28,21 +28,20 @@ const countdownProps = buildProps({
    * @description target time
    */
   value: {
-    type: definePropType([Number, Object]),
+    type: t([Number, Object]),
     default: 0
   },
   /**
    * @description Styles countdown values
    */
   valueStyle: {
-    type: definePropType([String, Object, Array])
+    type: t([String, Object, Array])
   }
-});
-const countdownEmits = {
-  finish: () => true,
-  [CHANGE_EVENT]: (value) => isNumber(value)
+}), a = {
+  finish: () => !0,
+  [o]: (r) => i(r)
 };
 export {
-  countdownEmits,
-  countdownProps
+  a as countdownEmits,
+  l as countdownProps
 };

package/es/components/countdown/countdown.vue.js

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

package/es/components/countdown/countdown.vue2.js

@@ -1,92 +1,65 @@
-import { defineComponent, ref, computed, onMounted, watch, onBeforeUnmount, createBlock, openBlock, unref, createSlots, renderList, withCtx, renderSlot } from "vue";
-import { VftStatistic } from "../statistic/index.js";
+import { defineComponent as p, ref as _, computed as h, onMounted as x, watch as y, onBeforeUnmount as C, createBlock as E, openBlock as S, unref as A, createSlots as B, renderList as F, withCtx as k, renderSlot as D } from "vue";
+import { VftStatistic as N } from "../statistic/index.js";
 import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
-import { CHANGE_EVENT } from "../../constants/event.js";
+import { CHANGE_EVENT as $ } from "../../constants/event.js";
 import "lodash-es";
-import { rAF, cAF } from "../../utils/vue/raf.js";
-import { countdownEmits, countdownProps } from "./countdown.js";
-import { formatTime, getTime } from "./utils.js";
-const __default__ = defineComponent({
+import { rAF as f, cAF as g } from "../../utils/vue/raf.js";
+import { countdownEmits as G, countdownProps as H } from "./countdown.js";
+import { formatTime as l, getTime as u } from "./utils.js";
+const L = p({
   name: "VftCountdown"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
-  props: countdownProps,
-  emits: countdownEmits,
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    let timer;
-    const rawValue = ref(0);
-    const displayValue = computed(() => formatTime(rawValue.value, props.format));
-    const formatter = (val) => formatTime(val, props.format);
-    const stopTimer = () => {
-      if (timer) {
-        cAF(timer);
-        timer = void 0;
-      }
-    };
-    const startTimer = () => {
-      const timestamp = getTime(props.value);
-      const frameFunc = () => {
-        let diff = timestamp - Date.now();
-        emit(CHANGE_EVENT, diff);
-        if (diff <= 0) {
-          diff = 0;
-          stopTimer();
-          emit("finish");
-        } else {
-          timer = rAF(frameFunc);
-        }
-        rawValue.value = diff;
+}), O = /* @__PURE__ */ p({
+  ...L,
+  props: H,
+  emits: G,
+  setup(c, { expose: d, emit: v }) {
+    const e = c, s = v;
+    let o;
+    const i = _(0), w = h(() => l(i.value, e.format)), T = (t) => l(t, e.format), m = () => {
+      o && (g(o), o = void 0);
+    }, V = () => {
+      const t = u(e.value), n = () => {
+        let r = t - Date.now();
+        s($, r), r <= 0 ? (r = 0, m(), s("finish")) : o = f(n), i.value = r;
       };
-      timer = rAF(frameFunc);
+      o = f(n);
     };
-    onMounted(() => {
-      rawValue.value = getTime(props.value) - Date.now();
-      watch(
-        () => [props.value, props.format],
+    return x(() => {
+      i.value = u(e.value) - Date.now(), y(
+        () => [e.value, e.format],
         () => {
-          stopTimer();
-          startTimer();
+          m(), V();
         },
         {
-          immediate: true
+          immediate: !0
         }
       );
-    });
-    onBeforeUnmount(() => {
-      stopTimer();
-    });
-    __expose({
+    }), C(() => {
+      m();
+    }), d({
       /**
        * @description current display value
        */
-      displayValue
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(VftStatistic), {
-        value: rawValue.value,
-        title: _ctx.title,
-        prefix: _ctx.prefix,
-        suffix: _ctx.suffix,
-        "value-style": _ctx.valueStyle,
-        formatter
-      }, createSlots({ _: 2 }, [
-        renderList(_ctx.$slots, (_, name) => {
-          return {
-            name,
-            fn: withCtx(() => [
-              renderSlot(_ctx.$slots, name)
-            ])
-          };
-        })
-      ]), 1032, ["value", "title", "prefix", "suffix", "value-style"]);
-    };
+      displayValue: w
+    }), (t, n) => (S(), E(A(N), {
+      value: i.value,
+      title: t.title,
+      prefix: t.prefix,
+      suffix: t.suffix,
+      "value-style": t.valueStyle,
+      formatter: T
+    }, B({ _: 2 }, [
+      F(t.$slots, (r, a) => ({
+        name: a,
+        fn: k(() => [
+          D(t.$slots, a)
+        ])
+      }))
+    ]), 1032, ["value", "title", "prefix", "suffix", "value-style"]));
   }
 });
 export {
-  _sfc_main as default
+  O as default
 };

package/es/components/countdown/index.js

@@ -2,14 +2,14 @@ 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 o } from "../../utils/vue/install.js";
 import "lodash-es";
-import _sfc_main from "./countdown.vue2.js";
-import { countdownEmits, countdownProps } from "./countdown.js";
-const VftCountdown = withInstall(_sfc_main);
+import t from "./countdown.vue2.js";
+import { countdownEmits as u, countdownProps as w } from "./countdown.js";
+const a = o(t);
 export {
-  VftCountdown,
-  countdownEmits,
-  countdownProps,
-  VftCountdown as default
+  a as VftCountdown,
+  u as countdownEmits,
+  w as countdownProps,
+  a as default
 };