@aplus-frontend/ui 0.0.1-beta.4 → 0.0.1-beta.6

package/es/src/ap-field/select/index.vue.d.ts

@@ -0,0 +1,235 @@
+import { DefaultOptionType, SelectValue, LabeledValue } from 'ant-design-vue/es/select';
+import { ApFieldSelectProps, FieldMode } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType, CSSProperties } from 'vue';
+import { VueTypeValidableDef } from '../../../node_modules/vue-types';
+import { ButtonSize } from 'ant-design-vue/es/button';
+import { VueNode } from 'ant-design-vue/es/_util/type';
+import { SelectHandler, FieldNames, FilterFunc } from 'ant-design-vue/es/vc-select/Select';
+import { RenderDOMFunc, DropdownRender, CustomTagProps } from 'ant-design-vue/es/vc-select/BaseSelect';
+import { AlignType } from 'ant-design-vue/es/vc-trigger/interface';
+
+type ApFieldSelectSlots = {
+    notFoundContent: any;
+    suffixIcon: any;
+    itemIcon: any;
+    removeIcon: any;
+    clearIcon: any;
+    dropdownRender: any;
+    option: any;
+    placeholder: any;
+    tagRender: any;
+    maxTagPlaceholder: any;
+    optionLabel: any;
+    default: any;
+};
+declare function focus(): void;
+declare function blur(): void;
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSelectProps>, {
+    fieldProps: () => {};
+    emptyText: string;
+    mode: string;
+}>, {
+    focus: typeof focus;
+    blur: typeof blur;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSelectProps>, {
+    fieldProps: () => {};
+    emptyText: string;
+    mode: string;
+}>>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    mode: FieldMode;
+    emptyText: string;
+    fieldProps: Omit<Partial< ExtractPropTypes<{
+        value: {
+            type: PropType<SelectValue>;
+            default: SelectValue;
+        };
+        defaultValue: {
+            type: PropType<SelectValue>;
+            default: SelectValue;
+        };
+        notFoundContent: VueTypeValidableDef<any>;
+        suffixIcon: VueTypeValidableDef<any>;
+        itemIcon: VueTypeValidableDef<any>;
+        size: {
+            type: PropType<ButtonSize>;
+            default: ButtonSize;
+        };
+        mode: {
+            type: PropType<"multiple" | "tags" | "SECRET_COMBOBOX_MODE_DO_NOT_USE">;
+            default: "multiple" | "tags" | "SECRET_COMBOBOX_MODE_DO_NOT_USE";
+        };
+        bordered: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transitionName: StringConstructor;
+        choiceTransitionName: {
+            type: PropType<"">;
+            default: "";
+        };
+        popupClassName: StringConstructor;
+        dropdownClassName: StringConstructor;
+        placement: {
+            type: PropType<"bottomLeft" | "bottomRight" | "topLeft" | "topRight">;
+            default: "bottomLeft" | "bottomRight" | "topLeft" | "topRight";
+        };
+        status: {
+            type: PropType<"" | "error" | "warning">;
+            default: "" | "error" | "warning";
+        };
+        'onUpdate:value': {
+            type: PropType<(val: SelectValue) => void>;
+            default: (val: SelectValue) => void;
+        };
+        children: PropType< VueNode[]>;
+        listHeight: NumberConstructor;
+        onMouseenter: PropType<(e: MouseEvent) => void>;
+        onMouseleave: PropType<(e: MouseEvent) => void>;
+        tabindex: NumberConstructor;
+        onClick: PropType<(e: MouseEvent) => void>;
+        onFocus: {
+            type: PropType<(e: FocusEvent) => void>;
+        };
+        onBlur: {
+            type: PropType<(e: FocusEvent) => void>;
+        };
+        onChange: PropType<(value: SelectValue, option: DefaultOptionType | DefaultOptionType[]) => void>;
+        onKeydown: PropType<(e: KeyboardEvent) => void>;
+        onKeyup: PropType<(e: KeyboardEvent) => void>;
+        onMousedown: PropType<(e: MouseEvent) => void>;
+        onSelect: PropType<SelectHandler<(string | number) | LabeledValue, DefaultOptionType>>;
+        open: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        animation: StringConstructor;
+        direction: {
+            type: PropType<"ltr" | "rtl">;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        prefixCls: StringConstructor;
+        id: StringConstructor;
+        autofocus: BooleanConstructor;
+        getPopupContainer: {
+            type: PropType<RenderDOMFunc>;
+        };
+        virtual: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        dropdownMatchSelectWidth: {
+            type: PropType<number | boolean>;
+            default: any;
+        };
+        options: PropType<DefaultOptionType[]>;
+        showAction: {
+            type: PropType<("click" | "focus")[]>;
+        };
+        placeholder: VueTypeValidableDef<any>;
+        onDeselect: PropType<SelectHandler<(string | number) | LabeledValue, DefaultOptionType>>;
+        loading: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        clearIcon: VueTypeValidableDef<any>;
+        allowClear: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onSearch: PropType<(value: string) => void>;
+        fieldNames: PropType<FieldNames>;
+        dropdownStyle: {
+            type: PropType<CSSProperties>;
+        };
+        dropdownRender: {
+            type: PropType<DropdownRender>;
+        };
+        dropdownAlign: PropType<AlignType>;
+        showSearch: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        searchValue: StringConstructor;
+        onInputKeyDown: PropType<(e: KeyboardEvent) => void>;
+        removeIcon: VueTypeValidableDef<any>;
+        maxTagCount: {
+            type: PropType<number | "responsive">;
+        };
+        maxTagTextLength: NumberConstructor;
+        maxTagPlaceholder: VueTypeValidableDef<any>;
+        tokenSeparators: {
+            type: PropType<string[]>;
+        };
+        tagRender: {
+            type: PropType<(props: CustomTagProps) => any>;
+        };
+        optionLabelRender: {
+            type: PropType<(option: Record<string, any>) => any>;
+        };
+        onClear: PropType<() => void>;
+        defaultOpen: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onDropdownVisibleChange: {
+            type: PropType<(open: boolean) => void>;
+        };
+        showArrow: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onPopupScroll: PropType<(e: UIEvent) => void>;
+        menuItemSelectedIcon: VueTypeValidableDef<any>;
+        listItemHeight: NumberConstructor;
+        inputValue: StringConstructor;
+        autoClearSearchValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        filterOption: {
+            type: PropType<boolean | FilterFunc<DefaultOptionType>>;
+            default: any;
+        };
+        filterSort: PropType<(optionA: DefaultOptionType, optionB: DefaultOptionType) => number>;
+        optionFilterProp: StringConstructor;
+        optionLabelProp: StringConstructor;
+        defaultActiveFirstOption: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        labelInValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+    }>>, "value" | "mode" | "onUpdate:value" | "onSearch">;
+}, {}>, Readonly<ApFieldSelectSlots> & ApFieldSelectSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-field/select/index.vue.mjs

@@ -0,0 +1,114 @@
+import { defineComponent as B, ref as d, onMounted as C, computed as v, unref as a, openBlock as h, createElementBlock as V, toDisplayString as T, createBlock as I, mergeProps as M, createSlots as R, renderList as U, withCtx as y, renderSlot as z, normalizeProps as N, guardReactiveProps as $, createVNode as j } from "vue";
+import { debounce as D, isFunction as P, isArray as E, isNil as L } from "lodash-unified";
+import { Select as G, Spin as H } from "ant-design-vue";
+import "../../hooks/useMessage.mjs";
+import { useControllableValue as J } from "../../hooks/useControllableValue.mjs";
+const K = { key: 0 }, ee = /* @__PURE__ */ B({
+  name: "ApFieldSelect",
+  __name: "index",
+  props: {
+    mode: { default: "edit" },
+    fieldProps: { default: () => ({}) },
+    emptyText: { default: "-" },
+    request: {},
+    multiple: { type: Boolean },
+    value: {},
+    "onUpdate:value": {}
+  },
+  emits: ["update:value"],
+  setup(S, { expose: g, emit: F }) {
+    var p, m;
+    let s = 0;
+    const b = (e, l) => typeof (l == null ? void 0 : l.label) == "string" && l.label.indexOf(e) > -1, w = D((e) => {
+      if (!P(t.request))
+        return;
+      s += 1;
+      const l = s;
+      u.value = [], n.value = !0, t.request(e).then((o) => {
+        s === l && (u.value = o);
+      }).finally(() => {
+        n.value = !1;
+      });
+    }, 300), t = S, u = d(((p = t.fieldProps) == null ? void 0 : p.options) || []), f = d(), n = d(((m = t.fieldProps) == null ? void 0 : m.loading) || !1), k = F;
+    C(() => {
+      if (P(t.request)) {
+        n.value = !0, s += 1;
+        const e = s;
+        t.request().then((l) => {
+          e === s && (u.value = l);
+        }).finally(() => {
+          n.value = !1;
+        });
+      }
+    });
+    const { value: c, updateValue: _ } = J(t, k), x = v(() => {
+      const e = a(c);
+      if (!e)
+        return t.emptyText;
+      if (E(e))
+        return e.map(
+          (o) => {
+            var r;
+            return (r = a(u).find((i) => i.value === o)) == null ? void 0 : r.label;
+          }
+        ).filter(Boolean).join("、") || t.emptyText;
+      const l = a(u).find((o) => o.value === e);
+      return (l == null ? void 0 : l.label) || t.emptyText;
+    }), O = v(() => {
+      var o, r, i;
+      const l = !!((o = t.fieldProps) != null && o.showSearch) ? {
+        showArrow: !1,
+        defaultActiveFirstOption: !1,
+        onSearch: w,
+        notFoundContent: n.value ? void 0 : null
+      } : {
+        showArrow: !0
+      };
+      return {
+        ...t.fieldProps,
+        ...l,
+        filterOption: t.fieldProps.showSearch ? !1 : L((r = t.fieldProps) == null ? void 0 : r.filterOption) ? b : (i = t.fieldProps) == null ? void 0 : i.filterOption
+      };
+    });
+    function q() {
+      var e;
+      (e = f.value) == null || e.focus();
+    }
+    function A() {
+      var e;
+      (e = f.value) == null || e.blur();
+    }
+    return g({
+      focus: q,
+      blur: A
+    }), (e, l) => e.mode === "read" ? (h(), V("span", K, T(x.value), 1)) : (h(), I(a(G), M({
+      key: 1,
+      "allow-clear": "",
+      ref_key: "selectRef",
+      ref: f
+    }, O.value, {
+      mode: e.multiple ? "multiple" : void 0,
+      value: a(c),
+      "onUpdate:value": a(_),
+      options: u.value,
+      loading: n.value
+    }), R({ _: 2 }, [
+      U(e.$slots, (o, r) => ({
+        name: r,
+        fn: y((i) => [
+          z(e.$slots, r, N($(i || {})))
+        ])
+      })),
+      n.value ? {
+        name: "notFoundContent",
+        fn: y(() => [
+          j(a(H), { size: "small" })
+        ]),
+        key: "0"
+      } : void 0
+    ]), 1040, ["mode", "value", "onUpdate:value", "options", "loading"]));
+  }
+});
+export {
+  ee as default
+};

package/es/src/ap-field/select/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/src/ap-field/switch/index.vue.d.ts

@@ -0,0 +1,54 @@
+import { ApFieldSwitchProps } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+type ApFieldSwitch = {
+    checkedChildren: any;
+    unCheckedChildren: any;
+    default: any;
+};
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSwitchProps>, {
+    emptyText: string;
+    checkedValue: boolean;
+    unCheckedValue: boolean;
+    size: string;
+    loading: undefined;
+}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:checked": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSwitchProps>, {
+    emptyText: string;
+    checkedValue: boolean;
+    unCheckedValue: boolean;
+    size: string;
+    loading: undefined;
+}>>> & {
+    "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
+}, {
+    size: "small" | "default";
+    loading: boolean;
+    checkedValue: string | number | boolean;
+    unCheckedValue: string | number | boolean;
+    emptyText: string;
+}, {}>, Readonly<ApFieldSwitch> & ApFieldSwitch>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-field/switch/index.vue.mjs

@@ -0,0 +1,93 @@
+import { defineComponent as v, useSlots as V, ref as B, computed as w, unref as c, createVNode as r, Fragment as u, openBlock as h, createBlock as p, resolveDynamicComponent as S, mergeProps as _, createSlots as A, renderList as N, withCtx as P, renderSlot as b, normalizeProps as F, guardReactiveProps as x } from "vue";
+import { Switch as z } from "ant-design-vue";
+import "../../hooks/useMessage.mjs";
+import { useControllableValue as D } from "../../hooks/useControllableValue.mjs";
+import { isNil as T, omit as U } from "lodash-unified";
+import { isDef as $ } from "@fruits-chain/utils";
+const E = /* @__PURE__ */ v({
+  name: "ApFieldSwitch",
+  __name: "index",
+  props: {
+    mode: {},
+    id: {},
+    prefixCls: {},
+    size: {
+      default: "default"
+    },
+    disabled: {
+      type: Boolean
+    },
+    checkedChildren: {},
+    unCheckedChildren: {},
+    tabindex: {},
+    autofocus: {
+      type: Boolean
+    },
+    loading: {
+      type: Boolean,
+      default: void 0
+    },
+    checked: {},
+    checkedValue: {
+      default: !0
+    },
+    unCheckedValue: {
+      default: !1
+    },
+    onChange: {},
+    onKeydown: {},
+    onMouseup: {},
+    "onUpdate:checked": {},
+    onBlur: {},
+    onFocus: {},
+    emptyText: {
+      default: "-"
+    },
+    onAction: {}
+  },
+  emits: ["update:checked"],
+  setup(m, {
+    emit: f
+  }) {
+    const o = V(), n = m, k = f, {
+      value: i,
+      updateValue: s
+    } = D(n, k, {
+      valuePropName: "checked"
+    }), l = B(!1);
+    async function C(e, a) {
+      if (!$(n.onAction)) {
+        s(e);
+        return;
+      }
+      l.value = !0;
+      try {
+        await n.onAction(e, a) && s(e);
+      } finally {
+        l.value = !1;
+      }
+    }
+    const y = w(() => {
+      var d, t;
+      const e = c(i);
+      return T(e) ? r(u, null, [n.emptyText]) : e === n.checkedValue ? r(u, null, [n.checkedChildren || ((d = o.checkedChildren) == null ? void 0 : d.call(o)) || n.checkedValue]) : r(u, null, [n.unCheckedChildren || ((t = o.unCheckedChildren) == null ? void 0 : t.call(o)) || n.unCheckedValue]);
+    });
+    return (e, a) => e.mode === "read" ? (h(), p(S(y.value), {
+      key: 0
+    })) : (h(), p(c(z), _({
+      key: 1
+    }, c(U)(n, "onUpdate:checked"), {
+      checked: c(i),
+      onClick: C,
+      loading: e.loading ?? l.value
+    }), A({
+      _: 2
+    }, [N(e.$slots, (d, t) => ({
+      name: t,
+      fn: P((g) => [b(e.$slots, t, F(x(g || {})))])
+    }))]), 1040, ["checked", "loading"]));
+  }
+});
+export {
+  E as default
+};

package/es/src/ap-field/switch/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/src/ap-field/text/index.vue.d.ts

@@ -0,0 +1,63 @@
+import { ApFieldTextProps, FieldMode } from '../interface';
+import { InputFocusOptions } from 'ant-design-vue/es/vc-input/utils/commonUtils';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+type ApFieldTextSlots = {
+    addonAfter(): any;
+    addonBefore(): any;
+    prefix(): any;
+    suffix(): any;
+    clearIcon(): any;
+};
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldTextProps>, {
+    emptyText: string;
+    mode: string;
+    bordered: boolean;
+    type: string;
+    lazy: boolean;
+}>, {
+    focus: (options?: InputFocusOptions | undefined) => void;
+    blur: () => void;
+    input: any;
+    setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none" | undefined) => void;
+    select: () => void;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldTextProps>, {
+    emptyText: string;
+    mode: string;
+    bordered: boolean;
+    type: string;
+    lazy: boolean;
+}>>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    mode: FieldMode;
+    type: "number" | "hidden" | "button" | "time" | "reset" | "submit" | "image" | "text" | "search" | "color" | "checkbox" | "radio" | "range" | "date" | "url" | "email" | "week" | "month" | "datetime-local" | "file" | "password" | "tel";
+    lazy: boolean;
+    bordered: boolean;
+    emptyText: string;
+}, {}>, Readonly<ApFieldTextSlots> & ApFieldTextSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-field/text/index.vue.mjs

@@ -0,0 +1,132 @@
+import { defineComponent as y, ref as x, useSlots as v, computed as B, openBlock as g, createBlock as b, resolveDynamicComponent as C, createVNode as r, mergeProps as h, unref as S, Fragment as _, isVNode as R } from "vue";
+import { Input as V } from "ant-design-vue";
+import "../../hooks/useMessage.mjs";
+import { useControllableValue as j } from "../../hooks/useControllableValue.mjs";
+import { omit as F } from "lodash-unified";
+function T(u) {
+  return typeof u == "function" || Object.prototype.toString.call(u) === "[object Object]" && !R(u);
+}
+const P = /* @__PURE__ */ y({
+  name: "ApFieldText",
+  __name: "index",
+  props: {
+    mode: {
+      default: "edit"
+    },
+    id: {},
+    placeholder: {},
+    autocomplete: {},
+    type: {
+      default: "text"
+    },
+    name: {},
+    size: {},
+    autofocus: {
+      type: Boolean
+    },
+    lazy: {
+      type: Boolean,
+      default: !0
+    },
+    maxlength: {},
+    loading: {
+      type: Boolean
+    },
+    bordered: {
+      type: Boolean,
+      default: !0
+    },
+    showCount: {
+      type: [Boolean, Object]
+    },
+    htmlSize: {},
+    onPressEnter: {},
+    onKeydown: {},
+    onKeyup: {},
+    onFocus: {},
+    onBlur: {},
+    onChange: {},
+    onInput: {},
+    "onUpdate:value": {},
+    onCompositionstart: {},
+    onCompositionend: {},
+    valueModifiers: {},
+    hidden: {
+      type: Boolean
+    },
+    status: {},
+    value: {},
+    defaultValue: {},
+    inputElement: {},
+    prefixCls: {},
+    disabled: {
+      type: Boolean
+    },
+    focused: {
+      type: Boolean
+    },
+    triggerFocus: {},
+    readonly: {
+      type: Boolean
+    },
+    handleReset: {},
+    addonBefore: {},
+    addonAfter: {},
+    prefix: {},
+    suffix: {},
+    clearIcon: {},
+    allowClear: {
+      type: Boolean
+    },
+    emptyText: {
+      default: "-"
+    }
+  },
+  emits: ["update:value"],
+  setup(u, {
+    expose: p,
+    emit: i
+  }) {
+    const a = x(), t = v();
+    p({
+      focus: (e) => {
+        var o;
+        (o = a.value) == null || o.focus(e);
+      },
+      blur: () => {
+        var e;
+        (e = a.value) == null || e.blur();
+      },
+      setSelectionRange: (e, o, m) => {
+        var l;
+        (l = a.value) == null || l.setSelectionRange(e, o, m);
+      },
+      select: () => {
+        var e;
+        (e = a.value) == null || e.select();
+      },
+      input: B(() => {
+        var e;
+        return (e = a.value) == null ? void 0 : e.input;
+      })
+    });
+    const c = i, n = u, {
+      value: d,
+      updateValue: f
+    } = j(n, c);
+    function s() {
+      var e, o;
+      return n.mode === "edit" ? r(V, h(F(n, ["mode", "emptyText"]), {
+        value: S(d),
+        "onUpdate:value": f,
+        ref: a
+      }), T(t) ? t : {
+        default: () => [t]
+      }) : r(_, null, [n.prefix || ((e = t == null ? void 0 : t.prefix) == null ? void 0 : e.call(t)), n.value || n.emptyText, n.suffix || ((o = t == null ? void 0 : t.suffix) == null ? void 0 : o.call(t))]);
+    }
+    return (e, o) => (g(), b(C(s())));
+  }
+});
+export {
+  P as default
+};