vft 0.0.380 → 0.0.384

package/es/components/menu/utils/submenu.js

@@ -1,63 +1,46 @@
-import { triggerEvent } from "@vft/utils";
-import { EVENT_CODE } from "@vft/constants";
-class SubMenu {
-  constructor(parent, domNode) {
-    this.parent = parent;
-    this.domNode = domNode;
-    this.subIndex = 0;
-    this.init();
+import { triggerEvent as n } from "@vft/utils";
+import { EVENT_CODE as t } from "@vft/constants";
+class h {
+  constructor(e, u) {
+    this.parent = e, this.domNode = u, this.subIndex = 0, this.init();
   }
   subMenuItems;
   subIndex = 0;
   init() {
-    this.subMenuItems = this.domNode.querySelectorAll("li");
-    this.addListeners();
+    this.subMenuItems = this.domNode.querySelectorAll("li"), this.addListeners();
   }
-  gotoSubIndex(idx) {
-    if (idx === this.subMenuItems.length) {
-      idx = 0;
-    } else if (idx < 0) {
-      idx = this.subMenuItems.length - 1;
-    }
-    this.subMenuItems[idx].focus();
-    this.subIndex = idx;
+  gotoSubIndex(e) {
+    e === this.subMenuItems.length ? e = 0 : e < 0 && (e = this.subMenuItems.length - 1), this.subMenuItems[e].focus(), this.subIndex = e;
   }
   addListeners() {
-    const parentNode = this.parent.domNode;
-    Array.prototype.forEach.call(this.subMenuItems, (el) => {
-      el.addEventListener("keydown", (event) => {
-        let prevDef = false;
-        switch (event.code) {
-          case EVENT_CODE.down: {
-            this.gotoSubIndex(this.subIndex + 1);
-            prevDef = true;
+    const e = this.parent.domNode;
+    Array.prototype.forEach.call(this.subMenuItems, (u) => {
+      u.addEventListener("keydown", (s) => {
+        let r = !1;
+        switch (s.code) {
+          case t.down: {
+            this.gotoSubIndex(this.subIndex + 1), r = !0;
             break;
           }
-          case EVENT_CODE.up: {
-            this.gotoSubIndex(this.subIndex - 1);
-            prevDef = true;
+          case t.up: {
+            this.gotoSubIndex(this.subIndex - 1), r = !0;
             break;
           }
-          case EVENT_CODE.tab: {
-            triggerEvent(parentNode, "mouseleave");
+          case t.tab: {
+            n(e, "mouseleave");
             break;
           }
-          case EVENT_CODE.enter:
-          case EVENT_CODE.space: {
-            prevDef = true;
-            event.currentTarget.click();
+          case t.enter:
+          case t.space: {
+            r = !0, s.currentTarget.click();
             break;
           }
         }
-        if (prevDef) {
-          event.preventDefault();
-          event.stopPropagation();
-        }
-        return false;
+        return r && (s.preventDefault(), s.stopPropagation()), !1;
       });
     });
   }
 }
 export {
-  SubMenu as default
+  h as default
 };

package/es/components/message/index.js

@@ -2,15 +2,15 @@ import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "vue";
-import { withInstallFunction } from "../../utils/vue/install.js";
+import { withInstallFunction as s } from "../../utils/vue/install.js";
 import "lodash-es";
-import message from "./method.js";
-import { messageDefaults, messageTypes } from "./types.js";
-const VftMessage = withInstallFunction(message, "$message");
+import e from "./method.js";
+import { messageDefaults as n, messageTypes as u } from "./types.js";
+const f = s(e, "$message");
 export {
-  VftMessage as Message,
-  VftMessage,
-  VftMessage as default,
-  messageDefaults,
-  messageTypes
+  f as Message,
+  f as VftMessage,
+  f as default,
+  n as messageDefaults,
+  u as messageTypes
 };

package/es/components/message/instance.js

@@ -1,26 +1,15 @@
-import { shallowReactive } from "vue";
-const instances = shallowReactive([]);
-const getInstance = (id) => {
-  const idx = instances.findIndex((instance) => instance.id === id);
-  const current = instances[idx];
-  let prev;
-  if (idx > 0) {
-    prev = instances[idx - 1];
-  }
-  return { current, prev };
-};
-const getLastOffset = (id) => {
-  const { prev } = getInstance(id);
-  if (!prev) return 0;
-  return prev.vm.exposed.bottom.value;
-};
-const getOffsetOrSpace = (id, offset) => {
-  const idx = instances.findIndex((instance) => instance.id === id);
-  return idx > 0 ? 20 : offset;
-};
+import { shallowReactive as c } from "vue";
+const r = c([]), i = (e) => {
+  const t = r.findIndex((o) => o.id === e), s = r[t];
+  let n;
+  return t > 0 && (n = r[t - 1]), { current: s, prev: n };
+}, f = (e) => {
+  const { prev: t } = i(e);
+  return t ? t.vm.exposed.bottom.value : 0;
+}, a = (e, t) => r.findIndex((n) => n.id === e) > 0 ? 20 : t;
 export {
-  getInstance,
-  getLastOffset,
-  getOffsetOrSpace,
-  instances
+  i as getInstance,
+  f as getLastOffset,
+  a as getOffsetOrSpace,
+  r as instances
 };

package/es/components/message/message.vue.js

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

package/es/components/message/message.vue2.js

@@ -1,15 +1,13 @@
-import { defineComponent, ref, computed, onMounted, watch, createBlock, openBlock, Transition, unref, withCtx, withDirectives, createElementVNode, normalizeStyle, normalizeClass, createElementBlock, createCommentVNode, renderSlot, createVNode, normalizeProps, guardReactiveProps, toDisplayString, withModifiers, vShow } from "vue";
-import { EVENT_CODE } from "@vft/constants";
-import { useEventListener } from "@vft/use";
-import { isObject } from "@vft/utils";
-import { VftIcon } from "../icon/index.js";
-import { useResizeObserver, useTimeoutFn } from "@vueuse/core";
+import { defineComponent as R, ref as f, computed as s, onMounted as V, watch as H, createBlock as $, openBlock as i, Transition as D, unref as n, withCtx as F, withDirectives as j, createElementVNode as P, normalizeStyle as U, normalizeClass as r, createElementBlock as c, createCommentVNode as h, renderSlot as Z, createVNode as w, normalizeProps as A, guardReactiveProps as G, toDisplayString as q, withModifiers as J, vShow as K } from "vue";
+import { EVENT_CODE as Q } from "@vft/constants";
+import { useEventListener as W } from "@vft/use";
+import { isObject as X } from "@vft/utils";
+import { VftIcon as k } from "../icon/index.js";
+import { useResizeObserver as Y, useTimeoutFn as _ } from "@vueuse/core";
 import "../config-provider/index.js";
-import { getLastOffset, getOffsetOrSpace } from "./instance.js";
-import { useGlobalComponentSettings } from "../config-provider/hooks/use-global-config.js";
-const _hoisted_1 = ["id"];
-const _hoisted_2 = ["innerHTML"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
+import { getLastOffset as x, getOffsetOrSpace as ee } from "./instance.js";
+import { useGlobalComponentSettings as oe } from "../config-provider/hooks/use-global-config.js";
+const ne = ["id"], te = ["innerHTML"], de = /* @__PURE__ */ R({
   __name: "message",
   props: {
     customClass: {},
@@ -28,129 +26,102 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     repeatNum: {}
   },
   emits: ["destroy"],
-  setup(__props, { expose: __expose }) {
-    const props = __props;
-    const { ns, zIndex } = useGlobalComponentSettings("message");
-    const { currentZIndex, nextZIndex } = zIndex;
-    const messageRef = ref();
-    const visible = ref(false);
-    const height = ref(0);
-    let stopTimer = void 0;
-    const iconCfgMap = /* @__PURE__ */ new Map([
+  setup(B, { expose: b }) {
+    const o = B, { ns: t, zIndex: M } = oe("message"), { currentZIndex: S, nextZIndex: T } = M, u = f(), l = f(!1), p = f(0);
+    let d;
+    const L = /* @__PURE__ */ new Map([
       ["success", { icon: "icon-success-filled" }],
       ["error", { icon: "icon-circle-close-filled" }],
       ["warning", { icon: "icon-warning-filled" }]
-    ]);
-    const iconCfg = computed(() => {
-      const _iconCfg = props.icon ? isObject(props.icon) ? props.icon : { icon: props.icon } : "";
-      return _iconCfg || iconCfgMap.get(props.type) || "";
-    });
-    const typeClass = computed(() => {
-      const type = props.type;
-      return { [ns.bm("icon", type)]: type };
-    });
-    const lastOffset = computed(() => getLastOffset(props.id));
-    const offset = computed(
-      () => getOffsetOrSpace(props.id, props.offset) + lastOffset.value
-    );
-    const bottom = computed(() => height.value + offset.value);
-    const customStyle = computed(() => ({
-      top: `${offset.value}px`,
-      zIndex: currentZIndex.value
+    ]), g = s(() => (o.icon ? X(o.icon) ? o.icon : { icon: o.icon } : "") || L.get(o.type) || ""), O = s(() => {
+      const e = o.type;
+      return { [t.bm("icon", e)]: e };
+    }), z = s(() => x(o.id)), v = s(
+      () => ee(o.id, o.offset) + z.value
+    ), E = s(() => p.value + v.value), I = s(() => ({
+      top: `${v.value}px`,
+      zIndex: S.value
     }));
-    function startTimer() {
-      if (props.duration === 0) return;
-      ({ stop: stopTimer } = useTimeoutFn(() => {
-        close();
-      }, props.duration));
+    function m() {
+      o.duration !== 0 && ({ stop: d } = _(() => {
+        a();
+      }, o.duration));
     }
-    function clearTimer() {
-      stopTimer?.();
+    function y() {
+      d?.();
     }
-    function close() {
-      visible.value = false;
+    function a() {
+      l.value = !1;
     }
-    function keydown({ code }) {
-      if (code === EVENT_CODE.esc) {
-        close();
-      }
+    function N({ code: e }) {
+      e === Q.esc && a();
     }
-    onMounted(() => {
-      startTimer();
-      nextZIndex();
-      visible.value = true;
-    });
-    watch(
-      () => props.repeatNum,
+    return V(() => {
+      m(), T(), l.value = !0;
+    }), H(
+      () => o.repeatNum,
       () => {
-        clearTimer();
-        startTimer();
+        y(), m();
       }
-    );
-    useEventListener(document, "keydown", keydown);
-    useResizeObserver(messageRef, () => {
-      height.value = messageRef.value.getBoundingClientRect().height;
-    });
-    __expose({
-      visible,
-      bottom,
-      close
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(Transition, {
-        name: unref(ns).b("fade"),
-        onBeforeLeave: _ctx.onClose,
-        onAfterLeave: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("destroy"))
-      }, {
-        default: withCtx(() => [
-          withDirectives(createElementVNode("div", {
-            id: _ctx.id,
-            ref_key: "messageRef",
-            ref: messageRef,
-            class: normalizeClass([
-              unref(ns).b(),
-              { [unref(ns).m(_ctx.type)]: _ctx.type && !_ctx.icon },
-              unref(ns).is("center", _ctx.center),
-              unref(ns).is("closable", _ctx.showClose),
-              _ctx.customClass
-            ]),
-            style: normalizeStyle(customStyle.value),
-            role: "alert",
-            onMouseenter: clearTimer,
-            onMouseleave: startTimer
+    ), W(document, "keydown", N), Y(u, () => {
+      p.value = u.value.getBoundingClientRect().height;
+    }), b({
+      visible: l,
+      bottom: E,
+      close: a
+    }), (e, C) => (i(), $(D, {
+      name: n(t).b("fade"),
+      onBeforeLeave: e.onClose,
+      onAfterLeave: C[0] || (C[0] = (se) => e.$emit("destroy"))
+    }, {
+      default: F(() => [
+        j(P("div", {
+          id: e.id,
+          ref_key: "messageRef",
+          ref: u,
+          class: r([
+            n(t).b(),
+            { [n(t).m(e.type)]: e.type && !e.icon },
+            n(t).is("center", e.center),
+            n(t).is("closable", e.showClose),
+            e.customClass
+          ]),
+          style: U(I.value),
+          role: "alert",
+          onMouseenter: y,
+          onMouseleave: m
+        }, [
+          g.value?.icon ? (i(), c("div", {
+            key: 0,
+            class: r([n(t).e("icon"), O.value])
           }, [
-            iconCfg.value?.icon ? (openBlock(), createElementBlock("div", {
-              key: 0,
-              class: normalizeClass([unref(ns).e("icon"), typeClass.value])
-            }, [
-              createVNode(unref(VftIcon), normalizeProps(guardReactiveProps(iconCfg.value)), null, 16)
-            ], 2)) : createCommentVNode("", true),
-            renderSlot(_ctx.$slots, "default", {}, () => [
-              !_ctx.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", {
-                key: 0,
-                class: normalizeClass(unref(ns).e("content"))
-              }, toDisplayString(_ctx.message), 3)) : (openBlock(), createElementBlock("p", {
-                key: 1,
-                class: normalizeClass(unref(ns).e("content")),
-                innerHTML: _ctx.message
-              }, null, 10, _hoisted_2))
-            ]),
-            _ctx.showClose ? (openBlock(), createElementBlock("div", {
+            w(n(k), A(G(g.value)), null, 16)
+          ], 2)) : h("", !0),
+          Z(e.$slots, "default", {}, () => [
+            e.dangerouslyUseHTMLString ? (i(), c("p", {
               key: 1,
-              class: normalizeClass(unref(ns).e("closeBtn")),
-              onClick: withModifiers(close, ["stop"])
-            }, [
-              createVNode(unref(VftIcon), { icon: "icon-circle-close" })
-            ], 2)) : createCommentVNode("", true)
-          ], 46, _hoisted_1), [
-            [vShow, visible.value]
-          ])
-        ]),
-        _: 3
-      }, 8, ["name", "onBeforeLeave"]);
-    };
+              class: r(n(t).e("content")),
+              innerHTML: e.message
+            }, null, 10, te)) : (i(), c("p", {
+              key: 0,
+              class: r(n(t).e("content"))
+            }, q(e.message), 3))
+          ]),
+          e.showClose ? (i(), c("div", {
+            key: 1,
+            class: r(n(t).e("closeBtn")),
+            onClick: J(a, ["stop"])
+          }, [
+            w(n(k), { icon: "icon-circle-close" })
+          ], 2)) : h("", !0)
+        ], 46, ne), [
+          [K, l.value]
+        ])
+      ]),
+      _: 3
+    }, 8, ["name", "onBeforeLeave"]));
   }
 });
 export {
-  _sfc_main as default
+  de as default
 };

package/es/components/message/method.js

@@ -1,123 +1,100 @@
-import { isNumber, isString, isFunction, isElement } from "@vft/utils";
-import { isVNode, createVNode, render } from "vue";
+import { isNumber as T, isString as f, isFunction as a, isElement as v } from "@vft/utils";
+import { isVNode as h, createVNode as C, render as u } from "vue";
 import "../config-provider/index.js";
-import { isClient } from "@vueuse/core";
-import { debugWarn } from "../../utils/error.js";
+import { isClient as b } from "@vueuse/core";
+import { debugWarn as y } from "../../utils/error.js";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { instances } from "./instance.js";
-import _sfc_main from "./message.vue2.js";
-import { messageDefaults, messageTypes } from "./types.js";
-import { messageConfig } from "../config-provider/constants.js";
-let seed = 1;
-const normalizeOptions = (params) => {
-  const options = !params || isString(params) || isVNode(params) || isFunction(params) ? { message: params } : params;
-  const normalized = {
-    ...messageDefaults,
-    ...options
+import { instances as t } from "./instance.js";
+import E from "./message.vue2.js";
+import { messageDefaults as _, messageTypes as z } from "./types.js";
+import { messageConfig as g } from "../config-provider/constants.js";
+let M = 1;
+const x = (e) => {
+  const n = !e || f(e) || h(e) || a(e) ? { message: e } : e, o = {
+    ..._,
+    ...n
   };
-  if (!normalized.appendTo) {
-    normalized.appendTo = document.body;
-  } else if (isString(normalized.appendTo)) {
-    let appendTo = document.querySelector(normalized.appendTo);
-    if (!isElement(appendTo)) {
-      debugWarn(
-        "VftMessage",
-        "the appendTo option is not an HTMLElement. Falling back to document.body."
-      );
-      appendTo = document.body;
-    }
-    normalized.appendTo = appendTo;
+  if (!o.appendTo)
+    o.appendTo = document.body;
+  else if (f(o.appendTo)) {
+    let s = document.querySelector(o.appendTo);
+    v(s) || (y(
+      "VftMessage",
+      "the appendTo option is not an HTMLElement. Falling back to document.body."
+    ), s = document.body), o.appendTo = s;
   }
-  return normalized;
-};
-const closeMessage = (instance) => {
-  const idx = instances.indexOf(instance);
-  if (idx === -1) return;
-  instances.splice(idx, 1);
-  const { handler } = instance;
-  handler.close();
-};
-const createMessage = ({ appendTo, ...options }, context) => {
-  const id = `message_${seed++}`;
-  const userOnClose = options.onClose;
-  const container = document.createElement("div");
-  const props = {
-    ...options,
-    id,
+  return o;
+}, N = (e) => {
+  const n = t.indexOf(e);
+  if (n === -1) return;
+  t.splice(n, 1);
+  const { handler: o } = e;
+  o.close();
+}, O = ({ appendTo: e, ...n }, o) => {
+  const s = `message_${M++}`, r = n.onClose, c = document.createElement("div"), i = {
+    ...n,
+    id: s,
     onClose: () => {
-      userOnClose?.();
-      closeMessage(instance);
+      r?.(), N(d);
     },
     // 清除 message element 防止内存泄漏
     onDestroy: () => {
-      render(null, container);
+      u(null, c);
     }
-  };
-  const vnode = createVNode(
-    _sfc_main,
-    props,
-    isFunction(props.message) || isVNode(props.message) ? {
-      default: isFunction(props.message) ? props.message : () => props.message
+  }, l = C(
+    E,
+    i,
+    a(i.message) || h(i.message) ? {
+      default: a(i.message) ? i.message : () => i.message
     } : null
   );
-  vnode.appContext = context || message._context;
-  render(vnode, container);
-  appendTo.appendChild(container.firstElementChild);
-  const vm = vnode.component;
-  const handler = {
-    // instead of calling the onClose function directly,
-    // setting this value so that we can have the full lifecycle
-    // for out component, so that all closing steps will not be skipped.
-    close: () => {
-      vm.exposed.visible.value = false;
-    }
-  };
-  const instance = {
-    id,
-    vnode,
-    vm,
-    handler,
-    props: vnode.component.props
+  l.appContext = o || p._context, u(l, c), e.appendChild(c.firstElementChild);
+  const m = l.component, d = {
+    id: s,
+    vnode: l,
+    vm: m,
+    handler: {
+      // instead of calling the onClose function directly,
+      // setting this value so that we can have the full lifecycle
+      // for out component, so that all closing steps will not be skipped.
+      close: () => {
+        m.exposed.visible.value = !1;
+      }
+    },
+    props: l.component.props
   };
-  return instance;
-};
-const message = (options = {}, context) => {
-  if (!isClient) return { close: () => void 0 };
-  if (isNumber(messageConfig.max) && instances.length >= messageConfig.max) {
-    return { close: () => void 0 };
-  }
-  const normalized = normalizeOptions(options);
-  if (normalized.grouping && instances.length) {
-    const instance2 = instances.find(
-      ({ vnode: vm }) => vm.props?.message === normalized.message
+  return d;
+}, p = (e = {}, n) => {
+  if (!b) return { close: () => {
+  } };
+  if (T(g.max) && t.length >= g.max)
+    return { close: () => {
+    } };
+  const o = x(e);
+  if (o.grouping && t.length) {
+    const r = t.find(
+      ({ vnode: c }) => c.props?.message === o.message
     );
-    if (instance2) {
-      instance2.props.repeatNum += 1;
-      instance2.props.type = normalized.type;
-      return instance2.handler;
-    }
+    if (r)
+      return r.props.repeatNum += 1, r.props.type = o.type, r.handler;
   }
-  const instance = createMessage(normalized, context);
-  instances.push(instance);
-  return instance.handler;
+  const s = O(o, n);
+  return t.push(s), s.handler;
 };
-messageTypes.forEach((type) => {
-  message[type] = (options = {}, appContext) => {
-    const normalized = normalizeOptions(options);
-    return message({ ...normalized, type }, appContext);
+z.forEach((e) => {
+  p[e] = (n = {}, o) => {
+    const s = x(n);
+    return p({ ...s, type: e }, o);
   };
 });
-function closeAll(type) {
-  for (const instance of instances) {
-    if (!type || type === instance.props.type) {
-      instance.handler.close();
-    }
-  }
+function V(e) {
+  for (const n of t)
+    (!e || e === n.props.type) && n.handler.close();
 }
-message.closeAll = closeAll;
-message._context = null;
+p.closeAll = V;
+p._context = null;
 export {
-  closeAll,
-  message as default
+  V as closeAll,
+  p as default
 };

package/es/components/message/types.js

@@ -1,23 +1,22 @@
-import { isClient } from "@vueuse/core";
-const messageTypes = ["success", "info", "warning", "error"];
-const messageDefaults = {
+import { isClient as e } from "@vueuse/core";
+const o = ["success", "info", "warning", "error"], n = {
   customClass: "",
-  center: false,
-  dangerouslyUseHTMLString: false,
+  center: !1,
+  dangerouslyUseHTMLString: !1,
   duration: 3e3,
   icon: void 0,
   id: "",
   message: "",
   onClose: void 0,
-  showClose: false,
+  showClose: !1,
   type: "info",
   offset: 16,
   zIndex: 0,
-  grouping: false,
+  grouping: !1,
   repeatNum: 1,
-  appendTo: isClient ? document.body : void 0
+  appendTo: e ? document.body : void 0
 };
 export {
-  messageDefaults,
-  messageTypes
+  n as messageDefaults,
+  o as messageTypes
 };