vft 0.0.73 → 0.0.76

package/es/components/time-picker/common/props.js

@@ -2,10 +2,11 @@ import "@vft/utils";
 import "vue";
 import { buildProps as t, definePropType as e } from "../../../utils/vue/props/runtime.js";
 import "@vueuse/core";
+import { componentSizes as a } from "../../../constants/size.js";
 import "../../../utils/ns-cover.js";
 import "lodash";
-import { disabledTimeListsProps as a } from "../props/shared.js";
-const u = t({
+import { disabledTimeListsProps as r } from "../props/shared.js";
+const f = t({
   /**
    * @description same as `id` in native input
    */
@@ -52,7 +53,8 @@ const u = t({
    * @description Custom clear icon component
    */
   clearIcon: {
-    type: e([String, Object])
+    type: e([String, Object]),
+    default: "ico-ep:circle-close"
   },
   /**
    * @description whether the input is editable
@@ -72,7 +74,9 @@ const u = t({
    * @description size of Input
    */
   size: {
-    type: Object
+    type: String,
+    values: a,
+    required: !1
   },
   /**
    * @description whether TimePicker is read only
@@ -143,7 +147,7 @@ const u = t({
     type: Boolean,
     default: !1
   },
-  ...a,
+  ...r,
   /**
    * @description a function determining if a date is disabled with that date as its parameter. Should return a Boolean
    */
@@ -197,5 +201,5 @@ const u = t({
   unlinkPanels: Boolean
 });
 export {
-  u as timePickerDefaultProps
+  f as timePickerDefaultProps
 };

package/es/components/time-picker/time-picker-com/panel-time-range.vue2.js

@@ -6,8 +6,8 @@ import "@popperjs/core";
 import "../../../hooks/use-z-index/index.js";
 import "@vueuse/core";
 import { isArray as M } from "@vft/utils";
-import "../../../utils/ns-cover.js";
 import { EVENT_CODE as ve } from "../../../constants/aria.js";
+import "../../../utils/ns-cover.js";
 import { panelTimeRangeProps as he } from "../props/panel-time-range.js";
 import { useTimePanel as ke } from "../composables/use-time-panel.js";
 import { useOldValue as Se, buildAvailableTimeSlotGetter as De } from "../composables/use-time-picker.js";

package/es/components/time-picker/time-picker.js

@@ -1,17 +1,17 @@
-import { defineComponent as p, ref as s, provide as u, createVNode as m, mergeProps as f } from "vue";
+import { defineComponent as p, ref as f, provide as s, createVNode as m, mergeProps as u } from "vue";
 import d from "dayjs";
 import c from "dayjs/plugin/customParseFormat.js";
 import { DEFAULT_FORMATS_TIME as P } from "./constants.js";
 import _ from "./common/picker.vue2.js";
 import h from "./time-picker-com/panel-time-pick.vue2.js";
-import v from "./time-picker-com/panel-time-range.vue2.js";
-import { timePickerDefaultProps as O } from "./common/props.js";
+import V from "./time-picker-com/panel-time-range.vue2.js";
+import { timePickerDefaultProps as v } from "./common/props.js";
 d.extend(c);
-const I = /* @__PURE__ */ p({
-  name: "ElTimePicker",
+const R = /* @__PURE__ */ p({
+  name: "VftTimePicker",
   install: null,
   props: {
-    ...O,
+    ...v,
     /**
      * @description whether to pick a time range
      */
@@ -22,8 +22,8 @@ const I = /* @__PURE__ */ p({
   },
   emits: ["update:modelValue"],
   setup(r, a) {
-    const t = s(), [n, l] = r.isRange ? ["timerange", v] : ["time", h], i = (e) => a.emit("update:modelValue", e);
-    return u("ElPopperOptions", r.popperOptions), a.expose({
+    const t = f(), [n, l] = r.isRange ? ["timerange", V] : ["time", h], i = (e) => a.emit("update:modelValue", e);
+    return s("VftPopperOptions", r.popperOptions), a.expose({
       /**
        * @description focus the Input component
        */
@@ -54,7 +54,7 @@ const I = /* @__PURE__ */ p({
       }
     }), () => {
       const e = r.format ?? P;
-      return m(_, f(r, {
+      return m(_, u(r, {
         ref: t,
         type: n,
         format: e,
@@ -66,5 +66,5 @@ const I = /* @__PURE__ */ p({
   }
 });
 export {
-  I as default
+  R as default
 };

package/es/components/time-select/time-select.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent as v, ref as E, computed as r, openBlock as a, createBlock as i, unref as n, withCtx as p, normalizeClass as S, resolveDynamicComponent as h, createCommentVNode as w, createElementBlock as D, Fragment as H, renderList as N } from "vue";
+import { defineComponent as v, ref as E, computed as r, openBlock as s, createBlock as u, unref as n, withCtx as f, normalizeClass as S, createCommentVNode as h, createElementBlock as w, Fragment as H, renderList as N } from "vue";
 import d from "dayjs";
 import O from "dayjs/plugin/customParseFormat.js";
 import b from "../select-v2/index.js";
@@ -11,59 +11,59 @@ import "../../hooks/use-z-index/index.js";
 import "@vueuse/core";
 import "@vft/utils";
 import "../../utils/ns-cover.js";
-import { timeSelectProps as L } from "./time-select.js";
-import { parseTime as m, formatTime as s, compareTime as c, nextTime as U } from "./utils.js";
-import { useFormDisabled as q } from "../form/hooks/use-form-common-props.js";
-const A = v({
+import { timeSelectProps as D } from "./time-select.js";
+import { parseTime as a, formatTime as m, compareTime as p, nextTime as L } from "./utils.js";
+import { useFormDisabled as U } from "../form/hooks/use-form-common-props.js";
+const q = v({
   name: "ElTimeSelect"
-}), ae = /* @__PURE__ */ v({
-  ...A,
-  props: L,
+}), ne = /* @__PURE__ */ v({
+  ...q,
+  props: D,
   emits: ["change", "blur", "focus", "update:modelValue"],
   setup(T, { expose: k }) {
     const o = T;
     d.extend(O);
-    const { Option: C } = b, V = j("input"), u = E(), y = q(), I = r(() => o.modelValue), g = r(() => {
-      const e = m(o.start);
-      return e ? s(e) : null;
-    }), f = r(() => {
-      const e = m(o.end);
-      return e ? s(e) : null;
+    const { Option: V } = b, C = j("input"), i = E(), I = U(), g = r(() => o.modelValue), y = r(() => {
+      const e = a(o.start);
+      return e ? m(e) : null;
+    }), c = r(() => {
+      const e = a(o.end);
+      return e ? m(e) : null;
     }), z = r(() => {
-      const e = m(o.step);
-      return e ? s(e) : null;
+      const e = a(o.step);
+      return e ? m(e) : null;
     }), B = r(() => {
-      const e = m(o.minTime || "");
-      return e ? s(e) : null;
+      const e = a(o.minTime || "");
+      return e ? m(e) : null;
     }), F = r(() => {
-      const e = m(o.maxTime || "");
-      return e ? s(e) : null;
+      const e = a(o.maxTime || "");
+      return e ? m(e) : null;
     }), $ = r(() => {
       const e = [];
       if (o.start && o.end && o.step) {
-        let t = g.value, l;
-        for (; t && f.value && c(t, f.value) <= 0; )
+        let t = y.value, l;
+        for (; t && c.value && p(t, c.value) <= 0; )
           l = d(t, "HH:mm").format(o.format), e.push({
             value: l,
-            disabled: c(t, B.value || "-1:-1") <= 0 || c(t, F.value || "100:100") >= 0
-          }), t = U(t, z.value);
+            disabled: p(t, B.value || "-1:-1") <= 0 || p(t, F.value || "100:100") >= 0
+          }), t = L(t, z.value);
       }
       return e;
     });
     return k({
       blur: () => {
         var e, t;
-        (t = (e = u.value) == null ? void 0 : e.blur) == null || t.call(e);
+        (t = (e = i.value) == null ? void 0 : e.blur) == null || t.call(e);
       },
       focus: () => {
         var e, t;
-        (t = (e = u.value) == null ? void 0 : e.focus) == null || t.call(e);
+        (t = (e = i.value) == null ? void 0 : e.focus) == null || t.call(e);
       }
-    }), (e, t) => (a(), i(n(b), {
+    }), (e, t) => (s(), u(n(b), {
       ref_key: "select",
-      ref: u,
-      "model-value": n(I),
-      disabled: n(y),
+      ref: i,
+      "model-value": n(g),
+      disabled: n(I),
       clearable: e.clearable,
       "clear-icon": e.clearIcon,
       size: e.size,
@@ -76,19 +76,15 @@ const A = v({
       onBlur: t[2] || (t[2] = (l) => e.$emit("blur", l)),
       onFocus: t[3] || (t[3] = (l) => e.$emit("focus", l))
     }, {
-      prefix: p(() => [
-        e.prefixIcon ? (a(), i(n(P), {
+      prefix: f(() => [
+        e.prefixIcon ? (s(), u(n(P), {
           key: 0,
-          class: S(n(V).e("prefix-icon"))
-        }, {
-          default: p(() => [
-            (a(), i(h(e.prefixIcon)))
-          ]),
-          _: 1
-        }, 8, ["class"])) : w("", !0)
+          icon: e.prefixIcon,
+          class: S(n(C).e("prefix-icon"))
+        }, null, 8, ["icon", "class"])) : h("", !0)
       ]),
-      default: p(() => [
-        (a(!0), D(H, null, N(n($), (l) => (a(), i(n(C), {
+      default: f(() => [
+        (s(!0), w(H, null, N(n($), (l) => (s(), u(n(V), {
           key: l.value,
           label: l.value,
           value: l.value,
@@ -100,5 +96,5 @@ const A = v({
   }
 });
 export {
-  ae as default
+  ne as default
 };

package/es/components/tooltip/content.vue2.js

@@ -62,7 +62,7 @@ const ae = E({
       onHide: S,
       onBeforeShow: f,
       onBeforeHide: d
-    } = U(ne, void 0), L = o(() => e.transition || `${w.namespace.value}-fade-in-linear`), I = o(() => process.env.NODE_ENV === "test" ? !0 : e.persistent);
+    } = U(ne, void 0), L = o(() => e.transition ?? `${w.namespace.value}-fade-in-linear`), I = o(() => process.env.NODE_ENV === "test" ? !0 : e.persistent);
     W(() => {
       c.value = !0;
     });

package/es/components/tree/index.js

@@ -0,0 +1,14 @@
+import e from "./tree.vue.js";
+import { dragEventsKey as s, useDragNodeHandler as d } from "./model/useDragNode.js";
+import { getChildState as l } from "./model/node.js";
+e.install = (t) => {
+  t.component(e.name, e);
+};
+const r = e, a = r;
+export {
+  a as VftTree,
+  r as default,
+  s as dragEventsKey,
+  l as getChildState,
+  d as useDragNodeHandler
+};

package/es/components/tree/model/node.js

@@ -0,0 +1,248 @@
+import { reactive as v } from "vue";
+import { hasOwn as D } from "@vft/utils";
+import { markNodeData as C, NODE_KEY as y } from "./util.js";
+const N = (r) => {
+  let e = !0, t = !0, s = !0;
+  for (let i = 0, a = r.length; i < a; i++) {
+    const h = r[i];
+    (h.checked !== !0 || h.indeterminate) && (e = !1, h.disabled || (s = !1)), (h.checked !== !1 || h.indeterminate) && (t = !1);
+  }
+  return { all: e, none: t, allWithoutDisable: s, half: !e && !t };
+}, o = function(r) {
+  if (r.childNodes.length === 0 || r.loading)
+    return;
+  const { all: e, none: t, half: s } = N(r.childNodes);
+  e ? (r.checked = !0, r.indeterminate = !1) : s ? (r.checked = !1, r.indeterminate = !0) : t && (r.checked = !1, r.indeterminate = !1);
+  const i = r.parent;
+  !i || i.level === 0 || r.store.checkStrictly || o(i);
+}, l = function(r, e) {
+  const t = r.store.props, s = r.data || {}, i = t[e];
+  if (typeof i == "function")
+    return i(s, r);
+  if (typeof i == "string")
+    return s[i];
+  if (typeof i > "u") {
+    const a = s[e];
+    return a === void 0 ? "" : a;
+  }
+};
+let L = 0;
+class f {
+  constructor(e) {
+    this.id = L++, this.text = null, this.checked = !1, this.indeterminate = !1, this.data = null, this.expanded = !1, this.parent = null, this.visible = !0, this.isCurrent = !1, this.canFocus = !1;
+    for (const t in e)
+      D(e, t) && (this[t] = e[t]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
+  }
+  initialize() {
+    const e = this.store;
+    if (!e)
+      throw new Error("[Node]store is required!");
+    e.registerNode(this);
+    const t = e.props;
+    if (t && typeof t.isLeaf < "u") {
+      const a = l(this, "isLeaf");
+      typeof a == "boolean" && (this.isLeafByUser = a);
+    }
+    if (e.lazy !== !0 && this.data ? (this.setData(this.data), e.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && e.lazy && e.defaultExpandAll && this.expand(), Array.isArray(this.data) || C(this, this.data), !this.data)
+      return;
+    const s = e.defaultExpandedKeys, i = e.key;
+    i && s && s.includes(this.key) && this.expand(null, e.autoExpandParent), i && e.currentNodeKey !== void 0 && this.key === e.currentNodeKey && (e.currentNode = this, e.currentNode.isCurrent = !0), e.lazy && e._initDefaultCheckedNode(this), this.updateLeafState(), this.parent && (this.level === 1 || this.parent.expanded === !0) && (this.canFocus = !0);
+  }
+  setData(e) {
+    Array.isArray(e) || C(this, e), this.data = e, this.childNodes = [];
+    let t;
+    this.level === 0 && Array.isArray(this.data) ? t = this.data : t = l(this, "children") || [];
+    for (let s = 0, i = t.length; s < i; s++)
+      this.insertChild({ data: t[s] });
+  }
+  get label() {
+    return l(this, "label");
+  }
+  get key() {
+    const e = this.store.key;
+    return this.data ? this.data[e] : null;
+  }
+  get disabled() {
+    return l(this, "disabled");
+  }
+  get nextSibling() {
+    const e = this.parent;
+    if (e) {
+      const t = e.childNodes.indexOf(this);
+      if (t > -1)
+        return e.childNodes[t + 1];
+    }
+    return null;
+  }
+  get previousSibling() {
+    const e = this.parent;
+    if (e) {
+      const t = e.childNodes.indexOf(this);
+      if (t > -1)
+        return t > 0 ? e.childNodes[t - 1] : null;
+    }
+    return null;
+  }
+  contains(e, t = !0) {
+    return (this.childNodes || []).some(
+      (s) => s === e || t && s.contains(e)
+    );
+  }
+  remove() {
+    const e = this.parent;
+    e && e.removeChild(this);
+  }
+  insertChild(e, t, s) {
+    if (!e)
+      throw new Error("InsertChild error: child is required.");
+    if (!(e instanceof f)) {
+      if (!s) {
+        const i = this.getChildren(!0);
+        i.includes(e.data) || (typeof t > "u" || t < 0 ? i.push(e.data) : i.splice(t, 0, e.data));
+      }
+      Object.assign(e, {
+        parent: this,
+        store: this.store
+      }), e = v(new f(e)), e instanceof f && e.initialize();
+    }
+    e.level = this.level + 1, typeof t > "u" || t < 0 ? this.childNodes.push(e) : this.childNodes.splice(t, 0, e), this.updateLeafState();
+  }
+  insertBefore(e, t) {
+    let s;
+    t && (s = this.childNodes.indexOf(t)), this.insertChild(e, s);
+  }
+  insertAfter(e, t) {
+    let s;
+    t && (s = this.childNodes.indexOf(t), s !== -1 && (s += 1)), this.insertChild(e, s);
+  }
+  removeChild(e) {
+    const t = this.getChildren() || [], s = t.indexOf(e.data);
+    s > -1 && t.splice(s, 1);
+    const i = this.childNodes.indexOf(e);
+    i > -1 && (this.store && this.store.deregisterNode(e), e.parent = null, this.childNodes.splice(i, 1)), this.updateLeafState();
+  }
+  removeChildByData(e) {
+    let t = null;
+    for (let s = 0; s < this.childNodes.length; s++)
+      if (this.childNodes[s].data === e) {
+        t = this.childNodes[s];
+        break;
+      }
+    t && this.removeChild(t);
+  }
+  expand(e, t) {
+    const s = () => {
+      if (t) {
+        let i = this.parent;
+        for (; i.level > 0; )
+          i.expanded = !0, i = i.parent;
+      }
+      this.expanded = !0, e && e(), this.childNodes.forEach((i) => {
+        i.canFocus = !0;
+      });
+    };
+    this.shouldLoadData() ? this.loadData((i) => {
+      Array.isArray(i) && (this.checked ? this.setChecked(!0, !0) : this.store.checkStrictly || o(this), s());
+    }) : s();
+  }
+  doCreateChildren(e, t = {}) {
+    e.forEach((s) => {
+      this.insertChild(
+        Object.assign({ data: s }, t),
+        void 0,
+        !0
+      );
+    });
+  }
+  collapse() {
+    this.expanded = !1, this.childNodes.forEach((e) => {
+      e.canFocus = !1;
+    });
+  }
+  shouldLoadData() {
+    return this.store.lazy === !0 && this.store.load && !this.loaded;
+  }
+  updateLeafState() {
+    if (this.store.lazy === !0 && this.loaded !== !0 && typeof this.isLeafByUser < "u") {
+      this.isLeaf = this.isLeafByUser;
+      return;
+    }
+    const e = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === !0 && this.loaded === !0) {
+      this.isLeaf = !e || e.length === 0;
+      return;
+    }
+    this.isLeaf = !1;
+  }
+  setChecked(e, t, s, i) {
+    if (this.indeterminate = e === "half", this.checked = e === !0, this.store.checkStrictly)
+      return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const { all: h, allWithoutDisable: n } = N(this.childNodes);
+      !this.isLeaf && !h && n && (this.checked = !1, e = !1);
+      const c = () => {
+        if (t) {
+          const d = this.childNodes;
+          for (let u = 0, x = d.length; u < x; u++) {
+            const p = d[u];
+            i = i || e !== !1;
+            const m = p.disabled ? p.checked : i;
+            p.setChecked(m, t, !0, i);
+          }
+          const { half: k, all: g } = N(d);
+          g || (this.checked = g, this.indeterminate = k);
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            c(), o(this);
+          },
+          {
+            checked: e !== !1
+          }
+        );
+        return;
+      } else
+        c();
+    }
+    const a = this.parent;
+    !a || a.level === 0 || s || o(a);
+  }
+  getChildren(e = !1) {
+    if (this.level === 0)
+      return this.data;
+    const t = this.data;
+    if (!t)
+      return null;
+    const s = this.store.props;
+    let i = "children";
+    return s && (i = s.children || "children"), t[i] === void 0 && (t[i] = null), e && !t[i] && (t[i] = []), t[i];
+  }
+  updateChildren() {
+    const e = this.getChildren() || [], t = this.childNodes.map((a) => a.data), s = {}, i = [];
+    e.forEach((a, h) => {
+      const n = a[y];
+      !!n && t.findIndex((d) => d[y] === n) >= 0 ? s[n] = { index: h, data: a } : i.push({ index: h, data: a });
+    }), this.store.lazy || t.forEach((a) => {
+      s[a[y]] || this.removeChildByData(a);
+    }), i.forEach(({ index: a, data: h }) => {
+      this.insertChild({ data: h }, a);
+    }), this.updateLeafState();
+  }
+  loadData(e, t = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(t).length)) {
+      this.loading = !0;
+      const s = (i) => {
+        this.childNodes = [], this.doCreateChildren(i, t), this.loaded = !0, this.loading = !1, this.updateLeafState(), e && e.call(this, i);
+      };
+      this.store.load(this, s);
+    } else
+      e && e.call(this);
+  }
+}
+export {
+  f as default,
+  N as getChildState
+};