vft 0.0.428 → 0.0.430

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

@@ -0,0 +1,92 @@
+import { defineComponent as a, inject as E, ref as K, createBlock as O, openBlock as w, unref as e, normalizeClass as b, withCtx as D, renderSlot as N } from "vue";
+import { EVENT_CODE as g } from "@vft/constants";
+import "../popper/index.js";
+import "@vueuse/core";
+import "@vft/utils";
+import { composeEventHandlers as r } from "../../utils/event.js";
+import "../config-provider/hooks/use-global-config.js";
+import "lodash-es";
+import "../form/index.js";
+import { useNamespace as F } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import { TOOLTIP_INJECTION_KEY as I } from "./constants.js";
+import { whenTrigger as i } from "./utils.js";
+import R from "../popper/trigger.vue2.js";
+const V = a({
+  name: "VftTooltipTrigger"
+}), Z = /* @__PURE__ */ a({
+  ...V,
+  props: {
+    disabled: { type: Boolean },
+    trigger: { default: "hover" },
+    triggerKeys: { default: () => [g.enter, g.space] },
+    virtualRef: {},
+    virtualTriggering: { type: Boolean }
+  },
+  setup(t, { expose: m }) {
+    const f = F("tooltip"), { controlled: d, id: p, open: v, onOpen: s, onClose: u, onToggle: l } = E(
+      I,
+      void 0
+    ), C = K(null), n = () => {
+      if (e(d) || t.disabled)
+        return !0;
+    }, T = r(
+      n,
+      i(t.trigger, "hover", s)
+    ), h = r(
+      n,
+      i(t.trigger, "hover", u)
+    ), x = r(
+      n,
+      i(t.trigger, "click", (o) => {
+        o.button === 0 && l(o);
+      })
+    ), y = r(
+      n,
+      i(t.trigger, "focus", s)
+    ), B = r(
+      n,
+      i(t.trigger, "focus", u)
+    ), M = r(
+      n,
+      i(t.trigger, "contextmenu", (o) => {
+        o.preventDefault(), l(o);
+      })
+    ), k = r(
+      n,
+      (o) => {
+        const { code: c } = o;
+        t.triggerKeys.includes(c) && (o.preventDefault(), l(o));
+      }
+    );
+    return m({
+      /**
+       * @description trigger element
+       */
+      triggerRef: C
+    }), (o, c) => (w(), O(e(R), {
+      id: e(p),
+      "virtual-ref": t.virtualRef,
+      open: e(v),
+      "virtual-triggering": t.virtualTriggering,
+      class: b(e(f).e("trigger")),
+      onBlur: e(B),
+      onClick: e(x),
+      onContextmenu: e(M),
+      onFocus: e(y),
+      onMouseenter: e(T),
+      onMouseleave: e(h),
+      onKeydown: e(k)
+    }, {
+      default: D(() => [
+        N(o.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]));
+  }
+});
+export {
+  Z as default
+};

package/es/components/tree/tree-node.vue.js

@@ -0,0 +1,98 @@
+import f from "./tree-node.vue2.js";
+import { resolveComponent as a, withDirectives as g, createElementBlock as i, openBlock as r, withModifiers as d, normalizeClass as s, createElementVNode as v, createVNode as l, normalizeStyle as D, createBlock as p, createCommentVNode as t, withCtx as N, Fragment as y, renderList as E, vShow as k } from "vue";
+import w from "../../_virtual/_plugin-vue_export-helper.js";
+const $ = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], L = ["aria-expanded"];
+function S(e, n, c, B, M, V) {
+  const h = a("icon"), m = a("tree-checkbox"), u = a("node-content"), b = a("tree-node", !0), C = a("collapse-transition");
+  return g((r(), i("div", {
+    ref: "node$",
+    class: s([
+      e.ns.b("node"),
+      e.ns.is("expanded", e.expanded),
+      e.ns.is("current", e.node.isCurrent),
+      e.ns.is("hidden", !e.node.visible),
+      e.ns.is("focusable", !e.node.disabled),
+      e.ns.is("checked", !e.node.disabled && e.node.checked),
+      e.getNodeClass(e.node)
+    ]),
+    role: "treeitem",
+    tabindex: "-1",
+    "aria-expanded": e.expanded,
+    "aria-disabled": e.node.disabled,
+    "aria-checked": e.node.checked,
+    draggable: e.tree.props.draggable,
+    "data-key": e.getNodeKey(e.node),
+    onClick: n[1] || (n[1] = d((...o) => e.handleClick && e.handleClick(...o), ["stop"])),
+    onContextmenu: n[2] || (n[2] = (...o) => e.handleContextMenu && e.handleContextMenu(...o)),
+    onDragstart: n[3] || (n[3] = d((...o) => e.handleDragStart && e.handleDragStart(...o), ["stop"])),
+    onDragover: n[4] || (n[4] = d((...o) => e.handleDragOver && e.handleDragOver(...o), ["stop"])),
+    onDragend: n[5] || (n[5] = d((...o) => e.handleDragEnd && e.handleDragEnd(...o), ["stop"])),
+    onDrop: n[6] || (n[6] = d((...o) => e.handleDrop && e.handleDrop(...o), ["stop"]))
+  }, [
+    v("div", {
+      class: s(e.ns.be("node", "content")),
+      style: D({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+    }, [
+      l(h, {
+        icon: e.tree.props.icon || "icon-caret-right",
+        class: s([
+          e.ns.be("node", "expand-icon"),
+          e.ns.is("leaf", e.node.isLeaf),
+          {
+            expanded: !e.node.isLeaf && e.expanded
+          }
+        ]),
+        onClick: d(e.handleExpandIconClick, ["stop"])
+      }, null, 8, ["icon", "class", "onClick"]),
+      e.showCheckbox ? (r(), p(m, {
+        key: 0,
+        "model-value": e.node.checked,
+        indeterminate: e.node.indeterminate,
+        disabled: !!e.node.disabled,
+        onClick: n[0] || (n[0] = d(() => {
+        }, ["stop"])),
+        onChange: e.handleCheckChange
+      }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : t("", !0),
+      e.node.loading ? (r(), p(h, {
+        key: 1,
+        icon: "icon-loading",
+        rotate: "",
+        class: s([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+      }, null, 8, ["class"])) : t("", !0),
+      l(u, {
+        node: e.node,
+        "render-content": e.renderContent
+      }, null, 8, ["node", "render-content"])
+    ], 6),
+    l(C, null, {
+      default: N(() => [
+        !e.renderAfterExpand || e.childNodeRendered ? g((r(), i("div", {
+          key: 0,
+          class: s(e.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": e.expanded
+        }, [
+          (r(!0), i(y, null, E(e.node.childNodes, (o) => (r(), p(b, {
+            key: e.getNodeKey(o),
+            "render-content": e.renderContent,
+            "render-after-expand": e.renderAfterExpand,
+            "show-checkbox": e.showCheckbox,
+            node: o,
+            accordion: e.accordion,
+            props: e.props,
+            onNodeExpand: e.handleChildNodeExpand
+          }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))), 128))
+        ], 10, L)), [
+          [k, e.expanded]
+        ]) : t("", !0)
+      ]),
+      _: 1
+    })
+  ], 42, $)), [
+    [k, e.node.visible]
+  ]);
+}
+const O = /* @__PURE__ */ w(f, [["render", S]]);
+export {
+  O as default
+};

package/es/components/tree/tree.vue2.js

@@ -0,0 +1,253 @@
+import { defineComponent as Y, getCurrentInstance as x, ref as s, computed as Z, watch as i, provide as w, createElementBlock as m, openBlock as y, normalizeClass as h, unref as n, createCommentVNode as _, withDirectives as ee, Fragment as te, renderList as re, createBlock as oe, renderSlot as ne, createElementVNode as E, toDisplayString as de, vShow as ae } from "vue";
+import "../form/index.js";
+import "../icon/index.js";
+import "@vueuse/core";
+import "@vft/utils";
+import "../config-provider/hooks/use-global-config.js";
+import "lodash-es";
+import { useNamespace as le } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import ce from "./model/tree-store.js";
+import { useDragNodeHandler as se } from "./model/useDragNode.js";
+import { useKeydown as ie } from "./model/useKeydown.js";
+import { useNodeExpandEventBroadcast as ue } from "./model/useNodeExpandEventBroadcast.js";
+import { getNodeKey as pe, handleCurrentChange as B } from "./model/util.js";
+import ye from "./tree-node.vue.js";
+import { formItemContextKey as he } from "../form/constants.js";
+const $e = /* @__PURE__ */ Y({
+  __name: "tree",
+  props: {
+    data: { default: [] },
+    emptyText: {},
+    renderAfterExpand: { type: Boolean, default: !0 },
+    nodeKey: {},
+    checkStrictly: { type: Boolean },
+    defaultExpandAll: { type: Boolean },
+    expandOnClickNode: { type: Boolean, default: !0 },
+    checkOnClickNode: { type: Boolean },
+    checkDescendants: { type: Boolean },
+    autoExpandParent: { type: Boolean, default: !0 },
+    defaultCheckedKeys: {},
+    defaultExpandedKeys: {},
+    currentNodeKey: {},
+    renderContent: {},
+    showCheckbox: { type: Boolean },
+    draggable: { type: Boolean },
+    allowDrag: {},
+    allowDrop: {},
+    props: { default: {
+      children: "children",
+      label: "label",
+      disabled: "disabled"
+    } },
+    lazy: { type: Boolean },
+    highlightCurrent: { type: Boolean },
+    load: {},
+    filterNodeMethod: {},
+    accordion: { type: Boolean },
+    indent: { default: 18 },
+    icon: {}
+  },
+  emits: ["check-change", "current-change", "node-click", "node-contextmenu", "node-collapse", "node-expand", "check", "node-drag-start", "node-drag-end", "node-drop", "node-drag-leave", "node-drag-enter", "node-drag-over"],
+  setup(l, { expose: T, emit: D }) {
+    const t = l, f = D, C = x(), a = le("tree"), r = s(
+      new ce({
+        key: t.nodeKey,
+        data: t.data,
+        lazy: t.lazy,
+        props: t.props,
+        load: t.load,
+        currentNodeKey: t.currentNodeKey,
+        checkStrictly: t.checkStrictly,
+        checkDescendants: t.checkDescendants,
+        defaultCheckedKeys: t.defaultCheckedKeys,
+        defaultExpandedKeys: t.defaultExpandedKeys,
+        autoExpandParent: t.autoExpandParent,
+        defaultExpandAll: t.defaultExpandAll,
+        filterNodeMethod: t.filterNodeMethod
+      })
+    );
+    r.value.initialize();
+    const u = s(r.value.root), b = s(null), K = s(null), g = s(null), { broadcastExpanded: S } = ue(t), { dragState: p } = se({
+      props: t,
+      ctx: C,
+      el$: K,
+      dropIndicator$: g,
+      store: r
+    });
+    ie({ el$: K }, r);
+    const q = Z(() => {
+      const { childNodes: e } = u.value;
+      return !e || e.length === 0 || e.every(({ visible: o }) => !o);
+    });
+    i(
+      () => t.currentNodeKey,
+      (e) => {
+        r.value.setCurrentNodeKey(e);
+      }
+    ), i(
+      () => t.defaultCheckedKeys,
+      (e) => {
+        r.value.setDefaultCheckedKey(e);
+      }
+    ), i(
+      () => t.defaultExpandedKeys,
+      (e) => {
+        r.value.setDefaultExpandedKeys(e);
+      }
+    ), i(
+      () => t.data,
+      (e) => {
+        r.value.setData(e);
+      },
+      { deep: !0 }
+    ), i(
+      () => t.checkStrictly,
+      (e) => {
+        r.value.checkStrictly = e;
+      }
+    );
+    const A = (e) => {
+      if (!t.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      r.value.filter(e);
+    }, N = (e) => pe(t.nodeKey, e.data), $ = (e) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in getNodePath");
+      const o = r.value.getNode(e);
+      if (!o) return [];
+      const d = [o.data];
+      let c = o.parent;
+      for (; c && c !== u.value; )
+        d.push(c.data), c = c.parent;
+      return d.reverse();
+    }, z = (e, o) => r.value.getCheckedNodes(e, o), H = (e) => r.value.getCheckedKeys(e), k = () => {
+      const e = r.value.getCurrentNode();
+      return e ? e.data : null;
+    }, I = () => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in getCurrentKey");
+      const e = k();
+      return e ? e[t.nodeKey] : null;
+    }, M = (e, o) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCheckedNodes");
+      r.value.setCheckedNodes(e, o);
+    }, P = (e, o) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCheckedKeys");
+      r.value.setCheckedKeys(e, o);
+    }, O = (e, o, d) => {
+      r.value.setChecked(e, o, d);
+    }, V = () => r.value.getHalfCheckedNodes(), F = () => r.value.getHalfCheckedKeys(), L = (e, o = !0) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCurrentNode");
+      B(
+        r,
+        f,
+        () => r.value.setUserCurrentNode(e, o)
+      );
+    }, R = (e, o = !0) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCurrentKey");
+      B(
+        r,
+        f,
+        () => r.value.setCurrentNodeKey(e, o)
+      );
+    }, U = (e) => r.value.getNode(e), j = (e) => {
+      r.value.remove(e);
+    }, G = (e, o) => {
+      r.value.append(e, o);
+    }, J = (e, o) => {
+      r.value.insertBefore(e, o);
+    }, Q = (e, o) => {
+      r.value.insertAfter(e, o);
+    }, v = (e, o, d) => {
+      S(o), f("node-expand", e, o, d);
+    }, W = (e, o) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in updateKeyChild");
+      r.value.updateChildren(e, o);
+    }, X = (e, o) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in updateKeyChild");
+      r.value.updateNode(e, o);
+    };
+    return w("RootTree", {
+      ctx: C,
+      props: t,
+      store: r,
+      root: u,
+      currentNode: b,
+      instance: x()
+    }), w(he, void 0), T({
+      filter: A,
+      getNodeKey: N,
+      getNodePath: $,
+      getCheckedNodes: z,
+      getCheckedKeys: H,
+      getCurrentNode: k,
+      getCurrentKey: I,
+      setCheckedNodes: M,
+      setCheckedKeys: P,
+      setChecked: O,
+      getHalfCheckedNodes: V,
+      getHalfCheckedKeys: F,
+      setCurrentNode: L,
+      setCurrentKey: R,
+      getNode: U,
+      remove: j,
+      append: G,
+      insertBefore: J,
+      insertAfter: Q,
+      handleNodeExpand: v,
+      updateKeyChildren: W,
+      updateNode: X
+    }), (e, o) => (y(), m("div", {
+      ref_key: "el$",
+      ref: K,
+      class: h([
+        n(a).b(),
+        n(a).is("dragging", !!n(p).draggingNode),
+        n(a).is("drop-not-allow", !n(p).allowDrop),
+        n(a).is("drop-inner", n(p).dropType === "inner"),
+        { [n(a).m("highlight-current")]: l.highlightCurrent }
+      ]),
+      role: "tree"
+    }, [
+      (y(!0), m(te, null, re(u.value.childNodes, (d) => (y(), oe(ye, {
+        key: N(d),
+        node: d,
+        props: t,
+        accordion: l.accordion,
+        "render-after-expand": l.renderAfterExpand,
+        "show-checkbox": l.showCheckbox,
+        "render-content": l.renderContent,
+        onNodeExpand: v
+      }, null, 8, ["node", "accordion", "render-after-expand", "show-checkbox", "render-content"]))), 128)),
+      q.value ? (y(), m("div", {
+        key: 0,
+        class: h(n(a).e("empty-block"))
+      }, [
+        ne(e.$slots, "empty", {}, () => [
+          E("span", {
+            class: h(n(a).e("empty-text"))
+          }, de(l.emptyText ?? "暂无数据"), 3)
+        ])
+      ], 2)) : _("", !0),
+      ee(E("div", {
+        ref_key: "dropIndicator$",
+        ref: g,
+        class: h(n(a).e("drop-indicator"))
+      }, null, 2), [
+        [ae, n(p).showDropIndicator]
+      ])
+    ], 2));
+  }
+});
+export {
+  $e as default
+};

package/es/components/upload/upload-content.vue2.js

@@ -0,0 +1,220 @@
+import { defineComponent as D, shallowRef as I, createElementBlock as $, openBlock as q, withKeys as A, normalizeClass as T, withModifiers as w, unref as g, createBlock as N, renderSlot as L, createElementVNode as X, withCtx as G, nextTick as J } from "vue";
+import "../form/index.js";
+import "@vueuse/core";
+import { isObject as O, entriesOf as Q } from "@vft/utils";
+import { debugWarn as Y } from "../../utils/error.js";
+import "../config-provider/hooks/use-global-config.js";
+import { cloneDeep as F, isEqual as Z } from "lodash-es";
+import { useNamespace as _ } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import { ajaxUpload as ee } from "./ajax.js";
+import { genFileId as te } from "./constants.js";
+import oe from "./upload-dragger.vue2.js";
+import { validateFileType as P, isImageOrVideo as ae, validateFileSize as ne } from "./utils.js";
+import { useFormDisabled as ie } from "../form/hooks/use-form-common-props.js";
+import { useFormItem as le } from "../form/hooks/use-form-item.js";
+const se = ["onKeydown"], re = ["name", "multiple", "accept"], de = D({
+  name: "VftUploadContent",
+  inheritAttrs: !1
+}), Ue = /* @__PURE__ */ D({
+  ...de,
+  props: {
+    fileList: { default: [] },
+    replaceOnLimit: { type: Boolean, default: !1 },
+    action: { default: "#" },
+    headers: {},
+    method: { default: "post" },
+    data: {},
+    multiple: { type: Boolean, default: !1 },
+    name: { default: "file" },
+    drag: { type: Boolean, default: !1 },
+    withCredentials: { type: Boolean },
+    showFileList: { type: Boolean, default: !0 },
+    accept: { default: "" },
+    type: { default: "select" },
+    autoUpload: { type: Boolean, default: !1 },
+    listType: { default: "text" },
+    httpRequest: { type: Function, default: ee },
+    disabled: { type: Boolean },
+    limit: {},
+    maxSize: { default: void 0 },
+    sizeExceedMessage: { default: "文件大小超出限制" },
+    sizeWidth: { default: void 0 },
+    sizeHeight: { default: void 0 },
+    onSizeInvalid: {},
+    onTypeInvalid: {},
+    beforeUpload: {},
+    onRemove: {},
+    onStart: {},
+    onSuccess: {},
+    onProgress: {},
+    onError: {},
+    onExceed: {},
+    onSizeExceed: {}
+  },
+  setup(r, { expose: K }) {
+    const l = r, v = _("upload"), k = ie(), { formItem: V } = le(), u = I(
+      {}
+    ), b = I(), B = async (e) => {
+      if (e.length === 0) return;
+      const {
+        autoUpload: o,
+        limit: a,
+        fileList: i,
+        multiple: p,
+        onStart: m,
+        onExceed: E,
+        replaceOnLimit: S,
+        maxSize: d,
+        onSizeExceed: z,
+        sizeWidth: h,
+        sizeHeight: y,
+        onSizeInvalid: f,
+        accept: s,
+        onTypeInvalid: c
+      } = l;
+      if (s) {
+        const n = e.filter((t) => !P(t, s));
+        if (n.length > 0 && (n.forEach((t) => {
+          c && c(t, s);
+        }), e = e.filter((t) => P(t, s)), e.length === 0))
+          return;
+      }
+      if (d) {
+        const n = e.filter((t) => t.size > d);
+        if (n.length > 0 && (n.forEach((t) => {
+          z && z(t, d);
+        }), e = e.filter((t) => t.size <= d), e.length === 0))
+          return;
+      }
+      if (h && y) {
+        const n = [];
+        for (const t of e)
+          if (ae(t))
+            try {
+              const { isValid: x, width: M, height: W } = await ne(
+                t,
+                h,
+                y
+              );
+              x ? n.push(t) : f && f(t, M, W, h, y);
+            } catch (x) {
+              console.error("尺寸校验失败:", x);
+            }
+          else
+            n.push(t);
+        if (e = n, e.length === 0) return;
+      }
+      if (a && i && i.length + e.length > a && !(a === 1 && S)) {
+        E?.(e, i);
+        return;
+      }
+      p || (e = e.slice(0, 1));
+      for (const n of e) {
+        const t = n;
+        t.uid = te(), m?.(t), o && C(t);
+      }
+    }, C = async (e) => {
+      if (b.value.value = "", !l.beforeUpload)
+        return R(e);
+      let o, a = {};
+      try {
+        const p = l.data, m = l.beforeUpload(e);
+        a = O(l.data) ? F(l.data) : l.data, o = await m, O(l.data) && Z(p, a) && (a = F(l.data));
+      } catch {
+        o = !1;
+      }
+      if (o === !1) {
+        l.onRemove?.(e);
+        return;
+      }
+      let i = e;
+      o instanceof Blob && (o instanceof File ? i = o : i = new File([o], e.name, {
+        type: e.type
+      })), R(Object.assign(i, { uid: e.uid }), a);
+    }, R = (e, o) => {
+      const {
+        headers: a,
+        data: i,
+        method: p,
+        withCredentials: m,
+        name: E,
+        action: S,
+        onProgress: d,
+        onSuccess: z,
+        onError: h,
+        httpRequest: y
+      } = l, { uid: f } = e, s = {
+        headers: a || {},
+        withCredentials: m,
+        file: e,
+        data: o ?? (i || {}),
+        method: p,
+        filename: E,
+        action: S,
+        onProgress: (n) => {
+          d?.(n, e);
+        },
+        onSuccess: (n) => {
+          z?.(n, e), delete u.value[f];
+        },
+        onError: (n) => {
+          h?.(n, e), delete u.value[f];
+        }
+      }, c = y(s);
+      u.value[f] = c, c instanceof Promise && c.then(s.onSuccess, s.onError);
+    }, j = async (e) => {
+      const o = e.target.files;
+      o && (await B(Array.from(o)), J(() => {
+        V?.validate("change").catch((a) => Y(a));
+      }));
+    }, U = () => {
+      k.value || (b.value.value = "", b.value.click());
+    }, H = () => {
+      U();
+    };
+    return K({
+      abort: (e) => {
+        Q(u.value).filter(
+          e ? ([a]) => String(e.uid) === a : () => !0
+        ).forEach(([a, i]) => {
+          i instanceof XMLHttpRequest && i.abort(), delete u.value[a];
+        });
+      },
+      upload: C
+    }), (e, o) => (q(), $("div", {
+      class: T([g(v).b(), g(v).m(r.listType), g(v).is("drag", r.drag)]),
+      tabindex: "0",
+      onClick: U,
+      onKeydown: A(w(H, ["self"]), ["enter", "space"])
+    }, [
+      r.drag ? (q(), N(oe, {
+        key: 0,
+        disabled: g(k),
+        onFile: o[0] || (o[0] = (a) => B(a.file))
+      }, {
+        default: G(() => [
+          L(e.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["disabled"])) : L(e.$slots, "default", { key: 1 }),
+      X("input", {
+        ref_key: "inputRef",
+        ref: b,
+        class: T(g(v).e("input")),
+        name: r.name,
+        multiple: r.multiple,
+        accept: r.accept,
+        type: "file",
+        onChange: j,
+        onClick: o[1] || (o[1] = w(() => {
+        }, ["stop"]))
+      }, null, 42, re)
+    ], 42, se));
+  }
+});
+export {
+  Ue as default
+};