yc-design-vue 2.1.9 → 2.2.0

package/es/Input/Input.vue.js

@@ -1,4 +1,4 @@
-import { defineComponent, useSlots, toRefs, ref, computed, createElementBlock, openBlock, normalizeClass, unref, createBlock, createCommentVNode, createElementVNode, withCtx, renderSlot, withDirectives, mergeProps, withKeys, vShow, createSlots } from "vue";
+import { defineComponent, useSlots, ref, createElementBlock, openBlock, normalizeClass, unref, createBlock, createCommentVNode, createElementVNode, withCtx, renderSlot, withDirectives, createVNode, mergeProps, withKeys, vShow, toDisplayString } from "vue";
 import "../node_modules/b-tween/dist/b-tween.es.js";
 import "../node_modules/dayjs/dayjs.min.js";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
@@ -8,7 +8,6 @@ import "../node_modules/dayjs/plugin/isSameOrAfter.js";
 import "../node_modules/dayjs/plugin/isSameOrBefore.js";
 import "../_shared/utils/dom.js";
 import { getGlobalConfig } from "../_shared/utils/global-config.js";
-import { useControlValue } from "../_shared/utils/hooks.js";
 import "../_shared/utils/locale.js";
 import "../_shared/utils/time.js";
 import useLimitedInput from "./hooks/useLimitedInput.js";
@@ -17,9 +16,11 @@ import _sfc_main$2 from "../_shared/components/IconButton/index.vue.js";
 import _sfc_main$1 from "../_shared/components/PreventFocus/index.vue.js";
 /* empty css                                               */
 /* empty css                                   */
-import _sfc_main$3 from "./InputSuffix.vue.js";
-/* empty css                 */
-const _hoisted_1 = ["value", "type", "disabled", "readonly", "placeholder"];
+const _hoisted_1 = ["value", "disabled", "readonly", "placeholder"];
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-input-word-limit"
+};
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
     name: "Input"
@@ -45,31 +46,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     inputAttrs: { default: () => {
       return {};
     } },
-    isPassword: { type: Boolean, default: false },
-    visibility: { type: Boolean, default: void 0 },
-    defaultVisibility: { type: Boolean, default: false },
-    invisibleButton: { type: Boolean, default: true },
     showInput: { type: Boolean, default: false }
   },
-  emits: ["update:modelValue", "update:visibility", "input", "change", "visibility-change", "pressEnter", "keydown", "clear", "focus", "blur"],
+  emits: ["update:modelValue", "input", "change", "pressEnter", "keydown", "clear", "focus", "blur"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const $slots = useSlots();
     const props = __props;
     const emits = __emit;
-    const { visibility, defaultVisibility } = toRefs(props);
     const { size } = getGlobalConfig(props);
     const inputRef = ref();
-    const computedVisibility = useControlValue(
-      visibility,
-      defaultVisibility.value,
-      (val) => {
-        emits("update:visibility", val);
-        emits("visibility-change", val);
-      }
-    );
-    const type = computed(() => {
-      return computedVisibility.value ? "password" : "text";
-    });
     const {
       computedValue,
       showWordLimit,
@@ -77,6 +62,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       curLength,
       maxLength,
       error,
+      recordCursor,
+      setCursor,
       handleInput,
       handleComposition
     } = useLimitedInput({
@@ -84,8 +71,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       emits,
       inputRef
     });
-    const handleEvent = async (type2, e) => {
-      switch (type2) {
+    const handleEvent = async (type, e) => {
+      switch (type) {
         case "input":
           {
             handleInput(e);
@@ -99,7 +86,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         case "focus":
         case "blur":
           {
-            emits(type2, e);
+            emits(type, e);
           }
           break;
         case "clear":
@@ -118,6 +105,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
     };
     __expose({
+      setCursor,
+      recordCursor,
       focus() {
         var _a;
         (_a = inputRef.value) == null ? void 0 : _a.focus();
@@ -166,10 +155,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           })) : createCommentVNode("", true),
           withDirectives(createElementVNode("input", mergeProps({
             value: unref(computedValue),
-            type: type.value,
             disabled: _ctx.disabled,
             readonly: _ctx.readonly,
-            placeholder: _ctx.placeholder
+            placeholder: _ctx.placeholder,
+            type: "text"
           }, _ctx.inputAttrs, {
             class: "yc-input",
             ref_key: "inputRef",
@@ -204,25 +193,14 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             class: "yc-input-clear-button",
             onClick: _cache[8] || (_cache[8] = ($event) => handleEvent("clear", $event))
           })) : createCommentVNode("", true),
-          $slots.suffix || unref(showWordLimit) || _ctx.isPassword && _ctx.invisibleButton ? (openBlock(), createBlock(_sfc_main$3, {
-            key: 3,
-            "cur-length": unref(curLength),
-            "max-length": unref(maxLength),
-            "computed-value": unref(computedValue),
-            "show-word-limit": unref(showWordLimit),
-            "computed-visibility": unref(computedVisibility),
-            "invisible-button": _ctx.invisibleButton,
-            "is-password": _ctx.isPassword,
-            onVisibilityChange: _cache[9] || (_cache[9] = (v) => computedVisibility.value = v)
-          }, createSlots({ _: 2 }, [
-            $slots.suffix ? {
-              name: "suffix",
-              fn: withCtx(() => [
-                renderSlot(_ctx.$slots, "suffix")
-              ]),
-              key: "0"
-            } : void 0
-          ]), 1032, ["cur-length", "max-length", "computed-value", "show-word-limit", "computed-visibility", "invisible-button", "is-password"])) : createCommentVNode("", true)
+          createVNode(unref(_sfc_main$1), { class: "yc-input-suffix" }, {
+            default: withCtx(() => [
+              unref(showWordLimit) ? (openBlock(), createElementBlock("div", _hoisted_2, toDisplayString(unref(curLength)) + "/" + toDisplayString(unref(maxLength)), 1)) : createCommentVNode("", true),
+              renderSlot(_ctx.$slots, "extra"),
+              renderSlot(_ctx.$slots, "suffix")
+            ]),
+            _: 3
+          })
         ], 2),
         $slots.append ? (openBlock(), createBlock(unref(_sfc_main$1), {
           key: 1,

package/es/Input/InputPassword.vue.d.ts

@@ -0,0 +1,309 @@
+import { InputPasswordProps } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prepend?(_: {}): any;
+        append?(_: {}): any;
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+    };
+    refs: {
+        inputRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | undefined;
+                readonly defaultValue?: string | undefined;
+                readonly size?: import('..').Size | undefined;
+                readonly allowClear?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly error?: boolean | undefined;
+                readonly placeholder?: string | undefined;
+                readonly maxLength?: import('./type').MaxLength | undefined;
+                readonly wordLength?: import('./type').WordLength | undefined;
+                readonly wordSlice?: import('./type').WordSlice | undefined;
+                readonly showWordLimit?: boolean | undefined;
+                readonly inputAttrs?: import('..').RecordType | undefined;
+                readonly showInput?: boolean | undefined;
+                readonly onChange?: ((value: string, ev: Event) => any) | undefined;
+                readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
+                readonly onClear?: ((ev: MouseEvent) => any) | undefined;
+                readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
+                readonly onInput?: ((value: string, ev: Event) => any) | undefined;
+                readonly onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                readonly onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                inputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "change", value: string, ev: Event) => void) & ((event: "focus", ev: FocusEvent) => void) & ((event: "clear", ev: MouseEvent) => void) & ((event: "blur", ev: FocusEvent) => void) & ((event: "input", value: string, ev: Event) => void) & ((event: "keydown", ev: KeyboardEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", ev: KeyboardEvent) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./type').InputProps> & Readonly<{
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, {
+                focus(): void;
+                blur(): void;
+                getInputRef(): HTMLInputElement;
+                setCursor?: () => void;
+                recordCursor?: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                change: (value: string, ev: Event) => any;
+                focus: (ev: FocusEvent) => any;
+                clear: (ev: MouseEvent) => any;
+                blur: (ev: FocusEvent) => any;
+                input: (value: string, ev: Event) => any;
+                keydown: (ev: KeyboardEvent) => any;
+                "update:modelValue": (value: string) => any;
+                pressEnter: (ev: KeyboardEvent) => any;
+            }, string, {
+                error: boolean;
+                size: import('..').Size;
+                disabled: boolean;
+                placeholder: string;
+                modelValue: string;
+                defaultValue: string;
+                maxLength: import('./type').MaxLength;
+                showWordLimit: boolean;
+                allowClear: boolean;
+                readonly: boolean;
+                wordLength: import('./type').WordLength;
+                wordSlice: import('./type').WordSlice;
+                inputAttrs: import('..').RecordType;
+                showInput: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            error: boolean;
+            size: import('..').Size;
+            disabled: boolean;
+            placeholder: string;
+            modelValue: string;
+            defaultValue: string;
+            maxLength: import('./type').MaxLength;
+            showWordLimit: boolean;
+            allowClear: boolean;
+            readonly: boolean;
+            wordLength: import('./type').WordLength;
+            wordSlice: import('./type').WordSlice;
+            inputAttrs: import('..').RecordType;
+            showInput: boolean;
+        }> & Omit<Readonly<import('./type').InputProps> & Readonly<{
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "setCursor" | "recordCursor" | "getInputRef" | ("error" | "size" | "disabled" | "placeholder" | "modelValue" | "defaultValue" | "maxLength" | "showWordLimit" | "allowClear" | "readonly" | "wordLength" | "wordSlice" | "inputAttrs" | "showInput")> & import('vue').ShallowUnwrapRef<{
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+            setCursor?: () => void;
+            recordCursor?: () => void;
+        }> & {} & import('@vue/runtime-core').ComponentCustomProperties & {} & {
+            $slots: any;
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputPasswordProps, {
+    focus(): void;
+    blur(): void;
+    getInputRef(): HTMLInputElement;
+    setCursor?: () => void;
+    recordCursor?: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:visibility": (value: boolean) => any;
+    "visibility-change": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<InputPasswordProps> & Readonly<{
+    "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+    "onVisibility-change"?: ((value: boolean) => any) | undefined;
+}>, {
+    visibility: boolean;
+    defaultVisibility: boolean;
+    invisibleButton: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: string | undefined;
+            readonly defaultValue?: string | undefined;
+            readonly size?: import('..').Size | undefined;
+            readonly allowClear?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly error?: boolean | undefined;
+            readonly placeholder?: string | undefined;
+            readonly maxLength?: import('./type').MaxLength | undefined;
+            readonly wordLength?: import('./type').WordLength | undefined;
+            readonly wordSlice?: import('./type').WordSlice | undefined;
+            readonly showWordLimit?: boolean | undefined;
+            readonly inputAttrs?: import('..').RecordType | undefined;
+            readonly showInput?: boolean | undefined;
+            readonly onChange?: ((value: string, ev: Event) => any) | undefined;
+            readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
+            readonly onClear?: ((ev: MouseEvent) => any) | undefined;
+            readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
+            readonly onInput?: ((value: string, ev: Event) => any) | undefined;
+            readonly onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            readonly onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            inputRef: HTMLInputElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "change", value: string, ev: Event) => void) & ((event: "focus", ev: FocusEvent) => void) & ((event: "clear", ev: MouseEvent) => void) & ((event: "blur", ev: FocusEvent) => void) & ((event: "input", value: string, ev: Event) => void) & ((event: "keydown", ev: KeyboardEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", ev: KeyboardEvent) => void);
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./type').InputProps> & Readonly<{
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+            setCursor?: () => void;
+            recordCursor?: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            change: (value: string, ev: Event) => any;
+            focus: (ev: FocusEvent) => any;
+            clear: (ev: MouseEvent) => any;
+            blur: (ev: FocusEvent) => any;
+            input: (value: string, ev: Event) => any;
+            keydown: (ev: KeyboardEvent) => any;
+            "update:modelValue": (value: string) => any;
+            pressEnter: (ev: KeyboardEvent) => any;
+        }, string, {
+            error: boolean;
+            size: import('..').Size;
+            disabled: boolean;
+            placeholder: string;
+            modelValue: string;
+            defaultValue: string;
+            maxLength: import('./type').MaxLength;
+            showWordLimit: boolean;
+            allowClear: boolean;
+            readonly: boolean;
+            wordLength: import('./type').WordLength;
+            wordSlice: import('./type').WordSlice;
+            inputAttrs: import('..').RecordType;
+            showInput: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        error: boolean;
+        size: import('..').Size;
+        disabled: boolean;
+        placeholder: string;
+        modelValue: string;
+        defaultValue: string;
+        maxLength: import('./type').MaxLength;
+        showWordLimit: boolean;
+        allowClear: boolean;
+        readonly: boolean;
+        wordLength: import('./type').WordLength;
+        wordSlice: import('./type').WordSlice;
+        inputAttrs: import('..').RecordType;
+        showInput: boolean;
+    }> & Omit<Readonly<import('./type').InputProps> & Readonly<{
+        onChange?: ((value: string, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: string, ev: Event) => any) | undefined;
+        onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, "focus" | "blur" | "setCursor" | "recordCursor" | "getInputRef" | ("error" | "size" | "disabled" | "placeholder" | "modelValue" | "defaultValue" | "maxLength" | "showWordLimit" | "allowClear" | "readonly" | "wordLength" | "wordSlice" | "inputAttrs" | "showInput")> & import('vue').ShallowUnwrapRef<{
+        focus(): void;
+        blur(): void;
+        getInputRef(): HTMLInputElement;
+        setCursor?: () => void;
+        recordCursor?: () => void;
+    }> & {} & import('@vue/runtime-core').ComponentCustomProperties & {} & {
+        $slots: any;
+    }) | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Input/InputPassword.vue.js

@@ -0,0 +1,122 @@
+import { defineComponent, toRefs, ref, createBlock, openBlock, mergeProps, unref, createSlots, withCtx, createCommentVNode, renderSlot } from "vue";
+import "../node_modules/b-tween/dist/b-tween.es.js";
+import "../node_modules/dayjs/dayjs.min.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../node_modules/dayjs/plugin/duration.js";
+import "../node_modules/dayjs/plugin/toObject.js";
+import "../node_modules/dayjs/plugin/isSameOrAfter.js";
+import "../node_modules/dayjs/plugin/isSameOrBefore.js";
+import { sleep } from "../_shared/utils/dom.js";
+import { useControlValue } from "../_shared/utils/hooks.js";
+import "../_shared/utils/locale.js";
+import "../_shared/utils/time.js";
+import _sfc_main$2 from "../_shared/components/IconButton/index.vue.js";
+/* empty css                                          */
+/* empty css                                               */
+/* empty css                                   */
+import _sfc_main$4 from "../_shared/icons/IconEyeClose.vue.js";
+import _sfc_main$3 from "../_shared/icons/IconEyeOpen.vue.js";
+import _sfc_main$1 from "./Input.vue.js";
+/* empty css           */
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "InputPassword"
+  },
+  __name: "InputPassword",
+  props: {
+    visibility: { type: Boolean, default: void 0 },
+    defaultVisibility: { type: Boolean, default: false },
+    invisibleButton: { type: Boolean, default: true }
+  },
+  emits: ["update:visibility", "visibility-change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { visibility, defaultVisibility } = toRefs(props);
+    const computedVisibility = useControlValue(
+      visibility,
+      defaultVisibility.value,
+      (val) => {
+        emits("update:visibility", val);
+        emits("visibility-change", val);
+      }
+    );
+    const inputRef = ref();
+    const handleClick = async () => {
+      var _a, _b, _c, _d;
+      (_b = (_a = inputRef.value) == null ? void 0 : _a.recordCursor) == null ? void 0 : _b.call(_a);
+      await sleep(0);
+      computedVisibility.value = !computedVisibility.value;
+      (_d = (_c = inputRef.value) == null ? void 0 : _c.setCursor) == null ? void 0 : _d.call(_c);
+    };
+    __expose({
+      focus() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      },
+      blur() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.blur();
+      },
+      getInputRef() {
+        var _a;
+        return (_a = inputRef.value) == null ? void 0 : _a.getInputRef();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, mergeProps(_ctx.$attrs, {
+        "input-attrs": {
+          type: unref(computedVisibility) ? "text" : "password"
+        },
+        ref_key: "inputRef",
+        ref: inputRef
+      }), createSlots({
+        extra: withCtx(() => [
+          _ctx.invisibleButton ? (openBlock(), createBlock(unref(_sfc_main$2), {
+            key: 0,
+            size: 14,
+            onClick: handleClick
+          }, {
+            default: withCtx(() => [
+              unref(computedVisibility) ? (openBlock(), createBlock(unref(_sfc_main$3), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$4), { key: 1 }))
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        _: 2
+      }, [
+        _ctx.$slots.prepend ? {
+          name: "prepend",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "prepend")
+          ]),
+          key: "0"
+        } : void 0,
+        _ctx.$slots.append ? {
+          name: "append",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "append")
+          ]),
+          key: "1"
+        } : void 0,
+        _ctx.$slots.prefix ? {
+          name: "prefix",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "prefix")
+          ]),
+          key: "2"
+        } : void 0,
+        _ctx.$slots.suffix ? {
+          name: "suffix",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "suffix")
+          ]),
+          key: "3"
+        } : void 0
+      ]), 1040, ["input-attrs"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Input/InputPassword.vue2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./InputPassword.vue.js";
+export {
+  _sfc_main as default
+};