yc-design-vue 2.2.2 → 2.2.4

package/es/DatePicker/component/PickerInput.vue.d.ts

@@ -0,0 +1,297 @@
+import { nextTick } from 'vue';
+type __VLS_Props = {
+    type?: 'year' | 'month' | 'week' | 'time' | 'date';
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prefix?(_: {}): any;
+        'suffix-icon'?(_: {}): any;
+        content?(_: {}): 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('../../Input').MaxLength | undefined;
+                readonly wordLength?: import('../../Input').WordLength | undefined;
+                readonly wordSlice?: import('../../Input').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('../../Input').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('../../Input').MaxLength;
+                showWordLimit: boolean;
+                allowClear: boolean;
+                readonly: boolean;
+                wordLength: import('../../Input').WordLength;
+                wordSlice: import('../../Input').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 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('../../Input').MaxLength;
+            showWordLimit: boolean;
+            allowClear: boolean;
+            readonly: boolean;
+            wordLength: import('../../Input').WordLength;
+            wordSlice: import('../../Input').WordSlice;
+            inputAttrs: import('../..').RecordType;
+            showInput: boolean;
+        }> & Omit<Readonly<import('../../Input').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: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    type: "year" | "month" | "week" | "time" | "date";
+}, {}, {}, {}, 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('../../Input').MaxLength | undefined;
+            readonly wordLength?: import('../../Input').WordLength | undefined;
+            readonly wordSlice?: import('../../Input').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('../../Input').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('../../Input').MaxLength;
+            showWordLimit: boolean;
+            allowClear: boolean;
+            readonly: boolean;
+            wordLength: import('../../Input').WordLength;
+            wordSlice: import('../../Input').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 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('../../Input').MaxLength;
+        showWordLimit: boolean;
+        allowClear: boolean;
+        readonly: boolean;
+        wordLength: import('../../Input').WordLength;
+        wordSlice: import('../../Input').WordSlice;
+        inputAttrs: import('../..').RecordType;
+        showInput: boolean;
+    }> & Omit<Readonly<import('../../Input').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;
+}, any>;
+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/DatePicker/component/PickerInput.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./PickerInput.vue2.js";
+/* empty css                 */
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
+const PickerInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-9f7eea5c"]]);
+export {
+  PickerInput as default
+};

package/es/DatePicker/component/PickerInput.vue2.js

@@ -0,0 +1,121 @@
+import { defineComponent, toRefs, computed, ref, watch, nextTick, createBlock, openBlock, unref, mergeProps, isRef, withCtx, createVNode, normalizeClass, normalizeStyle, createSlots, createElementVNode, createCommentVNode, renderSlot, withModifiers } from "vue";
+import _sfc_main$2 from "../../_shared/components/IconButton/index.vue.js";
+/* empty css                                             */
+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 "../../_shared/utils/dom.js";
+import { useI18n } from "../../_shared/utils/locale.js";
+import "../../_shared/utils/time.js";
+/* empty css                                                  */
+/* empty css                                      */
+import _sfc_main$1 from "../../_shared/icons/IconCalendar.vue2.js";
+import usePickerInputContext from "../hooks/useContext.js";
+import Input from "../../Input/index.js";
+import Trigger from "../../Trigger/index.js";
+const _hoisted_1 = { class: "yc-picker-suffix-icon" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "PickerInput",
+  props: {
+    type: { default: "date" }
+  },
+  setup(__props) {
+    const $props = __props;
+    const { props, computedVisible, formatValue, showClearBtn, onClear } = usePickerInputContext().inject();
+    const {
+      popupContainer,
+      unmountOnClose,
+      readonly,
+      disabled,
+      position,
+      triggerProps,
+      size,
+      error,
+      disabledInput,
+      locale,
+      placeholder: _placeholder
+    } = toRefs(props);
+    const { t } = useI18n();
+    const placeholder = computed(() => {
+      var _a;
+      const key = `datePicker.placeholder.${$props.type}`;
+      return _placeholder.value || ((_a = locale.value) == null ? void 0 : _a[key]) || t(key);
+    });
+    const inputRef = ref();
+    watch(
+      () => computedVisible.value,
+      async (val) => {
+        var _a;
+        if (val) return;
+        await nextTick();
+        (_a = inputRef.value) == null ? void 0 : _a.blur();
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Trigger), mergeProps({
+        "popup-visible": unref(computedVisible),
+        "onUpdate:popupVisible": _cache[0] || (_cache[0] = ($event) => isRef(computedVisible) ? computedVisible.value = $event : null),
+        "popup-offset": 4,
+        "popup-container": unref(popupContainer),
+        "unmount-on-close": unref(unmountOnClose),
+        disabled: unref(disabled) || unref(readonly),
+        position: unref(position),
+        "prevent-focus": "",
+        trigger: "click",
+        "animation-name": "slide-dynamic-origin",
+        "need-transform-origin": ""
+      }, unref(triggerProps)), {
+        content: withCtx(() => [
+          renderSlot(_ctx.$slots, "content", {}, void 0, true)
+        ]),
+        default: withCtx(() => [
+          createVNode(unref(Input), {
+            "model-value": unref(formatValue),
+            placeholder: placeholder.value,
+            disabled: unref(disabled),
+            error: unref(error),
+            size: unref(size),
+            readonly: unref(readonly) || unref(disabledInput) || true,
+            style: normalizeStyle(_ctx.$attrs.style),
+            class: normalizeClass([
+              _ctx.$attrs.class,
+              {
+                "yc-picker-allow-clear": unref(showClearBtn)
+              }
+            ]),
+            ref_key: "inputRef",
+            ref: inputRef
+          }, createSlots({
+            suffix: withCtx(() => [
+              createElementVNode("div", _hoisted_1, [
+                renderSlot(_ctx.$slots, "suffix-icon", {}, () => [
+                  createVNode(unref(_sfc_main$1))
+                ], true)
+              ]),
+              unref(showClearBtn) ? (openBlock(), createBlock(unref(_sfc_main$2), {
+                key: 0,
+                onClick: withModifiers(unref(onClear), ["stop"])
+              }, null, 8, ["onClick"])) : createCommentVNode("", true)
+            ]),
+            _: 2
+          }, [
+            _ctx.$slots.prefix ? {
+              name: "prefix",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["model-value", "placeholder", "disabled", "error", "size", "readonly", "style", "class"])
+        ]),
+        _: 3
+      }, 16, ["popup-visible", "popup-container", "unmount-on-close", "disabled", "position"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/DatePicker/component/PickerPanel.vue.d.ts

@@ -0,0 +1,33 @@
+import { ShortcutsPosition, ShortcutType } from '../type';
+type __VLS_Props = {
+    locale: Record<string, any>;
+    shortcutsPosition: ShortcutsPosition;
+    shortcuts: ShortcutType[];
+    previewShortcut: boolean;
+    confirmBtnDisabled: boolean;
+    showConfirmBtn: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        extra?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    confirm: (ev: MouseEvent) => any;
+    "shortcut-select": (shortcut: ShortcutType, hover: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onConfirm?: ((ev: MouseEvent) => any) | undefined;
+    "onShortcut-select"?: ((shortcut: ShortcutType, hover: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/DatePicker/component/PickerPanel.vue.js

@@ -0,0 +1,104 @@
+import { defineComponent, createElementBlock, openBlock, normalizeClass, createVNode, createBlock, createCommentVNode, createElementVNode, unref, withCtx, Fragment, renderList, resolveDynamicComponent, renderSlot, createTextVNode, toDisplayString } from "vue";
+import { createReusableTemplate } from "../../node_modules/@vueuse/core/index.js";
+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 "../../_shared/utils/dom.js";
+import { useI18n } from "../../_shared/utils/locale.js";
+import "../../_shared/utils/time.js";
+import { getSlotFunction } from "../../_shared/utils/vue-utils.js";
+import Button from "../../Button/index.js";
+const _hoisted_1 = { class: "yc-picker-panel-wrapper" };
+const _hoisted_2 = { class: "yc-picker-footer" };
+const _hoisted_3 = {
+  key: 0,
+  class: "yc-picker-footer-extra-wrapper"
+};
+const _hoisted_4 = {
+  key: 1,
+  class: "yc-picker-footer-btn-wrapper"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "PickerPanel",
+  props: {
+    locale: {},
+    shortcutsPosition: {},
+    shortcuts: {},
+    previewShortcut: { type: Boolean },
+    confirmBtnDisabled: { type: Boolean },
+    showConfirmBtn: { type: Boolean }
+  },
+  emits: ["confirm", "shortcut-select"],
+  setup(__props) {
+    const props = __props;
+    const { define: DefineShortcuts, reuse: ReuseShortcuts } = createReusableTemplate();
+    const { t } = useI18n();
+    const getOkText = () => {
+      var _a;
+      const key = "datePicker.ok";
+      return ((_a = props.locale) == null ? void 0 : _a[key]) || t(key);
+    };
+    return (_ctx, _cache) => {
+      var _a, _b;
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-picker-container",
+          `yc-picker-container-shortcuts-${_ctx.shortcutsPosition}`
+        ])
+      }, [
+        createVNode(unref(DefineShortcuts), null, {
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass([
+                "yc-picker-shortcuts",
+                `yc-picker-shortcuts-${_ctx.shortcutsPosition}`
+              ])
+            }, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.shortcuts, (v, i) => {
+                return openBlock(), createBlock(unref(Button), {
+                  key: i,
+                  size: "mini",
+                  onClick: ($event) => _ctx.$emit("shortcut-select", v, false),
+                  onMouseenter: ($event) => _ctx.previewShortcut && _ctx.$emit("shortcut-select", v, true)
+                }, {
+                  default: withCtx(() => [
+                    (openBlock(), createBlock(resolveDynamicComponent(unref(getSlotFunction)(v.label))))
+                  ]),
+                  _: 2
+                }, 1032, ["onClick", "onMouseenter"]);
+              }), 128))
+            ], 2)
+          ]),
+          _: 1
+        }),
+        ["left", "right"].includes(_ctx.shortcutsPosition) && ((_a = _ctx.shortcuts) == null ? void 0 : _a.length) ? (openBlock(), createBlock(unref(ReuseShortcuts), { key: 0 })) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "default"),
+          createElementVNode("div", _hoisted_2, [
+            _ctx.$slots.extra ? (openBlock(), createElementBlock("div", _hoisted_3, [
+              renderSlot(_ctx.$slots, "extra")
+            ])) : createCommentVNode("", true),
+            _ctx.showConfirmBtn || _ctx.shortcutsPosition == "bottom" && ((_b = _ctx.shortcuts) == null ? void 0 : _b.length) ? (openBlock(), createElementBlock("div", _hoisted_4, [
+              _ctx.shortcutsPosition == "bottom" ? (openBlock(), createBlock(unref(ReuseShortcuts), { key: 0 })) : createCommentVNode("", true),
+              _ctx.showConfirmBtn ? (openBlock(), createBlock(unref(Button), {
+                key: 1,
+                disabled: _ctx.confirmBtnDisabled,
+                type: "primary",
+                size: "mini",
+                onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("confirm", $event))
+              }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(getOkText()), 1)
+                ]),
+                _: 1
+              }, 8, ["disabled"])) : createCommentVNode("", true)
+            ])) : createCommentVNode("", true)
+          ])
+        ])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/DatePicker/component/PickerPanel.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./PickerPanel.vue.js";
+/* empty css                 */
+export {
+  _sfc_main as default
+};

package/es/DatePicker/hooks/useContext.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { RecordType } from '../../_shared/type';
+import { DatePickerValue } from '../type';
+export interface PickerInputContext {
+    props: RecordType;
+    computedVisible: Ref<boolean>;
+    formatValue: Ref<string>;
+    showClearBtn: Ref<boolean>;
+    onClear: () => void;
+}
+export default function usePickerInputContext(): {
+    provide: (context: {
+        computedValue: Ref<DatePickerValue | DatePickerValue[]>;
+        computedVisible: Ref<boolean>;
+        formatValue: Ref<string>;
+        emits: (...args: any) => void;
+    }, props: RecordType) => void;
+    inject: () => PickerInputContext;
+};

package/es/DatePicker/hooks/useContext.js

@@ -0,0 +1,37 @@
+import { toRefs, provide, computed, inject, ref } from "vue";
+const PICKER_TRIGGER_CONTEXT = "picker--context";
+function usePickerInputContext() {
+  const provide$1 = (context, props) => {
+    const { computedVisible, computedValue, formatValue, emits } = context;
+    const { allowClear, disabled } = toRefs(props);
+    provide(PICKER_TRIGGER_CONTEXT, {
+      computedVisible,
+      formatValue,
+      props,
+      showClearBtn: computed(() => {
+        return !!computedValue.value && allowClear.value && !disabled.value;
+      }),
+      onClear: () => {
+        computedValue.value = "";
+        emits("clear");
+      }
+    });
+  };
+  const inject$1 = () => {
+    return inject(PICKER_TRIGGER_CONTEXT, {
+      computedVisible: ref(false),
+      formatValue: ref(""),
+      showClearBtn: ref(false),
+      props: ref({}),
+      onClear: () => {
+      }
+    });
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+}
+export {
+  usePickerInputContext as default
+};