vft 0.0.376 → 0.0.378

package/es/components/col/col.vue2.js

@@ -1,18 +1,19 @@
-import { defineComponent as c, inject as d, computed as n, createBlock as h, openBlock as $, resolveDynamicComponent as g, normalizeStyle as b, normalizeClass as v, withCtx as x, renderSlot as y } from "vue";
+import { defineComponent, inject, computed, createBlock, openBlock, resolveDynamicComponent, normalizeStyle, normalizeClass, withCtx, renderSlot } from "vue";
 import "../row/index.js";
 import "@vueuse/core";
-import { isNumber as u, isObject as _ } from "@vft/utils";
+import { isNumber, isObject } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useNamespace as C } from "../../hooks/use-namespace/index.js";
+import { useNamespace } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-import { rowContextKey as j } from "../row/constants.js";
-const E = c({
+import { rowContextKey } from "../row/constants.js";
+const __default__ = defineComponent({
   name: "vft-col"
-}), F = /* @__PURE__ */ c({
-  ...E,
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
   props: {
     tag: { default: "div" },
     xs: {},
@@ -25,36 +26,59 @@ const E = c({
     pull: { default: 0 },
     push: { default: 0 }
   },
-  setup(f) {
-    const e = C("col"), o = f, { gutter: a } = d(j, { gutter: n(() => 0) }), i = n(() => {
-      const t = {};
-      return a.value && (t.paddingLeft = t.paddingRight = `${a.value / 2}px`), t;
-    }), m = n(() => {
-      const t = [];
-      return ["span", "offset", "pull", "push"].forEach((s) => {
-        const l = o[s];
-        u(l) && (s === "span" ? t.push(e.b(`${o[s]}`)) : l > 0 && t.push(e.b(`${s}-${o[s]}`)));
-      }), ["xs", "sm", "md", "lg", "xl"].forEach((s) => {
-        u(o[s]) ? t.push(e.b(`${s}-${o[s]}`)) : _(o[s]) && Object.entries(o[s]).forEach(
-          ([l, r]) => {
-            t.push(
-              l !== "span" ? e.b(`${s}-${l}-${r}`) : e.b(`${s}-${r}`)
-            );
-          }
-        );
-      }), a.value && t.push(e.is("guttered")), [e.b(), t];
+  setup(__props) {
+    const ns = useNamespace("col");
+    const props = __props;
+    const { gutter } = inject(rowContextKey, { gutter: computed(() => 0) });
+    const style = computed(() => {
+      const styles = {};
+      if (gutter.value) {
+        styles.paddingLeft = styles.paddingRight = `${gutter.value / 2}px`;
+      }
+      return styles;
+    });
+    const colKls = computed(() => {
+      const classes = [];
+      const pos = ["span", "offset", "pull", "push"];
+      pos.forEach((prop) => {
+        const size = props[prop];
+        if (isNumber(size)) {
+          if (prop === "span") classes.push(ns.b(`${props[prop]}`));
+          else if (size > 0) classes.push(ns.b(`${prop}-${props[prop]}`));
+        }
+      });
+      const sizes = ["xs", "sm", "md", "lg", "xl"];
+      sizes.forEach((size) => {
+        if (isNumber(props[size])) {
+          classes.push(ns.b(`${size}-${props[size]}`));
+        } else if (isObject(props[size])) {
+          Object.entries(props[size]).forEach(
+            ([prop, sizeProp]) => {
+              classes.push(
+                prop !== "span" ? ns.b(`${size}-${prop}-${sizeProp}`) : ns.b(`${size}-${sizeProp}`)
+              );
+            }
+          );
+        }
+      });
+      if (gutter.value) {
+        classes.push(ns.is("guttered"));
+      }
+      return [ns.b(), classes];
     });
-    return (t, p) => ($(), h(g(t.tag), {
-      class: v(m.value),
-      style: b(i.value)
-    }, {
-      default: x(() => [
-        y(t.$slots, "default")
-      ]),
-      _: 3
-    }, 8, ["class", "style"]));
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
+        class: normalizeClass(colKls.value),
+        style: normalizeStyle(style.value)
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["class", "style"]);
+    };
   }
 });
 export {
-  F as default
+  _sfc_main as default
 };

package/es/components/col/index.js

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

package/es/components/collapse/collapse-item.js

@@ -2,8 +2,8 @@ import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "vue";
-import { buildProps as t, definePropType as e } from "../../utils/vue/props/runtime.js";
-const m = t({
+import { buildProps, definePropType } from "../../utils/vue/props/runtime.js";
+const collapseItemProps = buildProps({
   /**
    * @description title of the panel
    */
@@ -15,7 +15,7 @@ const m = t({
    * @description unique identification of the panel
    */
   name: {
-    type: e([String, Number]),
+    type: definePropType([String, Number]),
     default: void 0
   },
   /**
@@ -31,5 +31,5 @@ const m = t({
   disabled: Boolean
 });
 export {
-  m as collapseItemProps
+  collapseItemProps
 };

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

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

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

@@ -1,93 +1,101 @@
-import { defineComponent as C, createElementBlock as g, openBlock as x, normalizeClass as l, unref as e, createElementVNode as a, createVNode as b, withKeys as A, withModifiers as B, renderSlot as r, createTextVNode as D, toDisplayString as E, withCtx as N, withDirectives as S, vShow as T } from "vue";
-import { VftCollapseTransition as F } from "../collapse-transition/index.js";
-import { VftIcon as H } from "../icon/index.js";
-import { collapseItemProps as M } from "./collapse-item.js";
-import { useCollapseItem as z, useCollapseItemDOM as O } from "./use-collapse-item.js";
-const P = ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex"], W = ["id", "aria-hidden", "aria-labelledby"], j = C({
+import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, createVNode, withKeys, withModifiers, renderSlot, createTextVNode, toDisplayString, withCtx, withDirectives, vShow } from "vue";
+import { VftCollapseTransition } from "../collapse-transition/index.js";
+import { VftIcon } from "../icon/index.js";
+import { collapseItemProps } from "./collapse-item.js";
+import { useCollapseItem, useCollapseItemDOM } from "./use-collapse-item.js";
+const _hoisted_1 = ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex"];
+const _hoisted_2 = ["id", "aria-hidden", "aria-labelledby"];
+const __default__ = defineComponent({
   name: "VftCollapseItem"
-}), R = /* @__PURE__ */ C({
-  ...j,
-  props: M,
-  setup(v, { expose: K }) {
-    const d = v, {
-      focusing: p,
-      id: w,
-      isActive: s,
-      handleFocus: c,
-      handleHeaderClick: m,
-      handleEnterClick: f
-    } = z(d), {
-      arrowKls: y,
-      headKls: I,
-      rootKls: h,
-      itemTitleKls: V,
-      itemWrapperKls: k,
-      itemContentKls: $,
-      scopedContentId: n,
-      scopedHeadId: u
-    } = O(d, { focusing: p, isActive: s, id: w });
-    return K({
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: collapseItemProps,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const {
+      focusing,
+      id,
+      isActive,
+      handleFocus,
+      handleHeaderClick,
+      handleEnterClick
+    } = useCollapseItem(props);
+    const {
+      arrowKls,
+      headKls,
+      rootKls,
+      itemTitleKls,
+      itemWrapperKls,
+      itemContentKls,
+      scopedContentId,
+      scopedHeadId
+    } = useCollapseItemDOM(props, { focusing, isActive, id });
+    __expose({
       /** @description current collapse-item whether active */
-      isActive: s
-    }), (t, o) => (x(), g("div", {
-      class: l(e(h))
-    }, [
-      a("div", {
-        id: e(u),
-        class: l(e(I)),
-        "aria-expanded": e(s),
-        "aria-controls": e(n),
-        "aria-describedby": e(n),
-        tabindex: t.disabled ? -1 : 0,
-        role: "button",
-        onClick: o[0] || (o[0] = //@ts-ignore
-        (...i) => e(m) && e(m)(...i)),
-        onKeydown: o[1] || (o[1] = A(B(
-          //@ts-ignore
-          (...i) => e(f) && e(f)(...i),
-          ["stop"]
-        ), ["space", "enter"])),
-        onFocus: o[2] || (o[2] = //@ts-ignore
-        (...i) => e(c) && e(c)(...i)),
-        onBlur: o[3] || (o[3] = (i) => p.value = !1)
+      isActive
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(rootKls))
       }, [
-        a("span", {
-          class: l(e(V))
+        createElementVNode("div", {
+          id: unref(scopedHeadId),
+          class: normalizeClass(unref(headKls)),
+          "aria-expanded": unref(isActive),
+          "aria-controls": unref(scopedContentId),
+          "aria-describedby": unref(scopedContentId),
+          tabindex: _ctx.disabled ? -1 : 0,
+          role: "button",
+          onClick: _cache[0] || (_cache[0] = //@ts-ignore
+          (...args) => unref(handleHeaderClick) && unref(handleHeaderClick)(...args)),
+          onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(
+            //@ts-ignore
+            (...args) => unref(handleEnterClick) && unref(handleEnterClick)(...args),
+            ["stop"]
+          ), ["space", "enter"])),
+          onFocus: _cache[2] || (_cache[2] = //@ts-ignore
+          (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
+          onBlur: _cache[3] || (_cache[3] = ($event) => focusing.value = false)
         }, [
-          r(t.$slots, "title", { isActive: e(s) }, () => [
-            D(E(t.title), 1)
-          ])
-        ], 2),
-        r(t.$slots, "icon", { isActive: e(s) }, () => [
-          b(e(H), {
-            icon: t.icon,
-            class: l(e(y))
-          }, null, 8, ["icon", "class"])
-        ])
-      ], 42, P),
-      b(e(F), null, {
-        default: N(() => [
-          S(a("div", {
-            id: e(n),
-            role: "region",
-            class: l(e(k)),
-            "aria-hidden": !e(s),
-            "aria-labelledby": e(u)
+          createElementVNode("span", {
+            class: normalizeClass(unref(itemTitleKls))
           }, [
-            a("div", {
-              class: l(e($))
-            }, [
-              r(t.$slots, "default")
-            ], 2)
-          ], 10, W), [
-            [T, e(s)]
+            renderSlot(_ctx.$slots, "title", { isActive: unref(isActive) }, () => [
+              createTextVNode(toDisplayString(_ctx.title), 1)
+            ])
+          ], 2),
+          renderSlot(_ctx.$slots, "icon", { isActive: unref(isActive) }, () => [
+            createVNode(unref(VftIcon), {
+              icon: _ctx.icon,
+              class: normalizeClass(unref(arrowKls))
+            }, null, 8, ["icon", "class"])
           ])
-        ]),
-        _: 3
-      })
-    ], 2));
+        ], 42, _hoisted_1),
+        createVNode(unref(VftCollapseTransition), null, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("div", {
+              id: unref(scopedContentId),
+              role: "region",
+              class: normalizeClass(unref(itemWrapperKls)),
+              "aria-hidden": !unref(isActive),
+              "aria-labelledby": unref(scopedHeadId)
+            }, [
+              createElementVNode("div", {
+                class: normalizeClass(unref(itemContentKls))
+              }, [
+                renderSlot(_ctx.$slots, "default")
+              ], 2)
+            ], 10, _hoisted_2), [
+              [vShow, unref(isActive)]
+            ])
+          ]),
+          _: 3
+        })
+      ], 2);
+    };
   }
 });
 export {
-  R as default
+  _sfc_main as default
 };

package/es/components/collapse/collapse.js

@@ -1,11 +1,12 @@
 import "@vueuse/core";
-import { isNumber as i, isString as e, isArray as p } from "@vft/utils";
+import { isNumber, isString, isArray } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
-import { CHANGE_EVENT as m, UPDATE_MODEL_EVENT as n } from "../../constants/event.js";
+import { CHANGE_EVENT, UPDATE_MODEL_EVENT } from "../../constants/event.js";
 import "vue";
-import { mutable as s } from "../../utils/typescript.js";
-import { buildProps as a, definePropType as r } from "../../utils/vue/props/runtime.js";
-const t = (o) => i(o) || e(o) || p(o), b = a({
+import { mutable } from "../../utils/typescript.js";
+import { buildProps, definePropType } from "../../utils/vue/props/runtime.js";
+const emitChangeFn = (value) => isNumber(value) || isString(value) || isArray(value);
+const collapseProps = buildProps({
   /**
    * @description whether to activate accordion mode
    */
@@ -14,30 +15,31 @@ const t = (o) => i(o) || e(o) || p(o), b = a({
    * @description currently active panel, the type is `string` in accordion mode, otherwise it is `array`
    */
   modelValue: {
-    type: r([Array, String, Number]),
-    default: () => s([])
+    type: definePropType([Array, String, Number]),
+    default: () => mutable([])
   },
   /**
    * @description set expand icon position
    */
   expandIconPosition: {
-    type: r([String]),
+    type: definePropType([String]),
     default: "right"
   },
   /**
    * @description before-collapse hook before the collapse state changes. If `false` is returned or a `Promise` is returned and then is rejected, will stop collapsing
    */
   beforeCollapse: {
-    type: r(
+    type: definePropType(
       Function
     )
   }
-}), g = {
-  [n]: t,
-  [m]: t
+});
+const collapseEmits = {
+  [UPDATE_MODEL_EVENT]: emitChangeFn,
+  [CHANGE_EVENT]: emitChangeFn
 };
 export {
-  g as collapseEmits,
-  b as collapseProps,
-  t as emitChangeFn
+  collapseEmits,
+  collapseProps,
+  emitChangeFn
 };

package/es/components/collapse/collapse.vue.js

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

package/es/components/collapse/collapse.vue2.js

@@ -1,26 +1,33 @@
-import { defineComponent as o, createElementBlock as m, openBlock as i, normalizeClass as f, unref as u, renderSlot as _ } from "vue";
-import { collapseEmits as d, collapseProps as C } from "./collapse.js";
-import { useCollapse as v, useCollapseDOM as k } from "./use-collapse.js";
-const x = o({
+import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, renderSlot } from "vue";
+import { collapseEmits, collapseProps } from "./collapse.js";
+import { useCollapse, useCollapseDOM } from "./use-collapse.js";
+const __default__ = defineComponent({
   name: "VftCollapse"
-}), z = /* @__PURE__ */ o({
-  ...x,
-  props: C,
-  emits: d,
-  setup(s, { expose: t, emit: l }) {
-    const e = s, r = l, { activeNames: a, setActiveNames: n } = v(e, r), { rootKls: p } = k(e);
-    return t({
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: collapseProps,
+  emits: collapseEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { activeNames, setActiveNames } = useCollapse(props, emit);
+    const { rootKls } = useCollapseDOM(props);
+    __expose({
       /** @description active names */
-      activeNames: a,
+      activeNames,
       /** @description set active names */
-      setActiveNames: n
-    }), (c, B) => (i(), m("div", {
-      class: f(u(p))
-    }, [
-      _(c.$slots, "default")
-    ], 2));
+      setActiveNames
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(rootKls))
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
   }
 });
 export {
-  z as default
+  _sfc_main as default
 };

package/es/components/collapse/constants.js

@@ -1,4 +1,4 @@
-const e = Symbol("collapseContextKey");
+const collapseContextKey = Symbol("collapseContextKey");
 export {
-  e as collapseContextKey
+  collapseContextKey
 };

package/es/components/collapse/index.js

@@ -2,23 +2,24 @@ import "@vueuse/core";
 import "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "vue";
-import { withInstall as t, withNoopInstall as p } from "../../utils/vue/install.js";
+import { withInstall, withNoopInstall } from "../../utils/vue/install.js";
 import "lodash-es";
-import m from "./collapse.vue2.js";
-import o from "./collapse-item.vue2.js";
-import { collapseEmits as _, collapseProps as h, emitChangeFn as w } from "./collapse.js";
-import { collapseItemProps as V } from "./collapse-item.js";
-import { collapseContextKey as g } from "./constants.js";
-const c = t(m, {
-  CollapseItem: o
-}), x = p(o);
+import _sfc_main$1 from "./collapse.vue2.js";
+import _sfc_main from "./collapse-item.vue2.js";
+import { collapseEmits, collapseProps, emitChangeFn } from "./collapse.js";
+import { collapseItemProps } from "./collapse-item.js";
+import { collapseContextKey } from "./constants.js";
+const VftCollapse = withInstall(_sfc_main$1, {
+  CollapseItem: _sfc_main
+});
+const VftCollapseItem = withNoopInstall(_sfc_main);
 export {
-  c as VftCollapse,
-  x as VftCollapseItem,
-  g as collapseContextKey,
-  _ as collapseEmits,
-  V as collapseItemProps,
-  h as collapseProps,
-  c as default,
-  w as emitChangeFn
+  VftCollapse,
+  VftCollapseItem,
+  collapseContextKey,
+  collapseEmits,
+  collapseItemProps,
+  collapseProps,
+  VftCollapse as default,
+  emitChangeFn
 };