yc-design-vue 1.0.1

package/es/TimePicker/TimePicker.vue.d.ts

@@ -0,0 +1,147 @@
+import { TimePickerProps, TimePickerSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TimePickerSlots> & TimePickerSlots;
+    refs: {
+        panelRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+                scroll(value: string): Promise<void>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, 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<{}> & Omit<Readonly<{}> & Readonly<{}>, "scroll"> & import('vue').ShallowUnwrapRef<{
+            scroll(value: string): Promise<void>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                extra?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TimePickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (timeString: string | (string | undefined)[] | undefined, time: Date | (Date | undefined)[] | undefined) => any;
+    "update:popupVisible": (value: boolean) => any;
+    "popup-visible-change": (value: boolean) => any;
+    clear: () => any;
+    select: (timeString: string | (string | undefined)[] | undefined, time: Date | (Date | undefined)[] | undefined) => any;
+    "update:modelValue": (value: import('./type').TimePickerValue) => any;
+}, string, import('vue').PublicProps, Readonly<TimePickerProps> & Readonly<{
+    onChange?: ((timeString: string | (string | undefined)[] | undefined, time: Date | (Date | undefined)[] | undefined) => any) | undefined;
+    "onUpdate:popupVisible"?: ((value: boolean) => any) | undefined;
+    "onPopup-visible-change"?: ((value: boolean) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onSelect?: ((timeString: string | (string | undefined)[] | undefined, time: Date | (Date | undefined)[] | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').TimePickerValue) => any) | undefined;
+}>, {
+    size: import('..').Size;
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    disabled: boolean;
+    position: import('./type').TimePickerPosition;
+    unmountOnClose: boolean;
+    popupContainer: import('..').PopupContainer;
+    error: boolean;
+    type: import('./type').TimePickerType;
+    placeholder: string | string[];
+    triggerProps: import('../Trigger').TriggerProps;
+    format: string;
+    disabledHours: import('./type').DisabledHours;
+    disabledMinutes: import('./type').DisabledMinutes;
+    disabledSeconds: import('./type').DisabledSeconds;
+    hideDisabledOptions: boolean;
+    modelValue: import('./type').TimePickerValue;
+    defaultValue: import('./type').TimePickerValue;
+    allowClear: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    panelRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+            scroll(value: string): Promise<void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, 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<{}> & Omit<Readonly<{}> & Readonly<{}>, "scroll"> & import('vue').ShallowUnwrapRef<{
+        scroll(value: string): Promise<void>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            extra?(_: {}): 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/TimePicker/TimePicker.vue.js

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

package/es/TimePicker/TimePicker.vue2.js

@@ -0,0 +1,213 @@
+import { defineComponent, ref, createBlock, openBlock, unref, mergeProps, withCtx, createElementVNode, normalizeStyle, normalizeClass, createElementBlock, createCommentVNode, renderSlot, withModifiers, Fragment, createVNode, createSlots } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { isArray } from "../_shared/utils/is.js";
+import { isValidTimeRange } from "../_shared/utils/time.js";
+import { getGlobalConfig } from "../_shared/utils/global-config.js";
+import useContext from "./hooks/useContext.js";
+import IconButton from "../_shared/components/IconButton.vue.js";
+/* empty css                                         */
+/* empty css                         */
+import _sfc_main$1 from "../_shared/icons/IconTime.vue.js";
+import Trigger from "../Trigger/index.js";
+import TimePickerPanel from "./TimePickerPanel.vue.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "yc-picker-prefix"
+};
+const _hoisted_2 = ["value", "placeholder", "disabled", "readonly"];
+const _hoisted_3 = ["value", "placeholder", "disabled", "readonly"];
+const _hoisted_4 = { class: "yc-picker-suffix" };
+const _hoisted_5 = { class: "yc-picker-suffix-icon" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TimePicker",
+    inheritAttrs: false
+  },
+  __name: "TimePicker",
+  props: {
+    type: { default: "time" },
+    modelValue: { default: void 0 },
+    defaultValue: { default: (props) => {
+      return props.type == "time-range" ? [] : "";
+    } },
+    disabled: { type: Boolean, default: false },
+    allowClear: { type: Boolean, default: true },
+    readonly: { type: Boolean, default: false },
+    error: { type: Boolean, default: false },
+    format: { default: "HH:mm:ss" },
+    placeholder: { default: (props) => {
+      return props.type == "time-range" ? ["开始时间", "结束时间"] : "请选择时间";
+    } },
+    size: { default: void 0 },
+    popupContainer: { default: void 0 },
+    step: {},
+    disabledHours: { type: Function, default: () => [] },
+    disabledMinutes: { type: Function, default: () => [] },
+    disabledSeconds: { type: Function, default: () => [] },
+    hideDisabledOptions: { type: Boolean, default: false },
+    disableConfirm: { type: Boolean },
+    position: { default: "bl" },
+    popupVisible: { type: Boolean, default: void 0 },
+    defaultPopupVisible: { type: Boolean, default: false },
+    triggerProps: { default: () => {
+      return {};
+    } },
+    unmountOnClose: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "update:popupVisible", "change", "select", "clear", "popup-visible-change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { popupContainer, size } = getGlobalConfig(props);
+    const {
+      type,
+      computedValue,
+      computedVisible,
+      showClearBtn,
+      readonly,
+      disabled,
+      curIndex,
+      inputRefs,
+      format
+    } = useContext().provide(props, emits);
+    const panelRef = ref();
+    const handleClear = () => {
+      computedValue.value = type.value == "time-range" ? [] : "";
+      emits("clear");
+    };
+    const handleOpenPicker = (i) => {
+      var _a;
+      curIndex.value = i;
+      computedVisible.value = true;
+      (_a = panelRef.value) == null ? void 0 : _a.scroll(
+        isArray(computedValue.value) ? computedValue.value[i] : computedValue.value
+      );
+    };
+    const handleClickOutSide = () => {
+      computedVisible.value = false;
+      if (!isArray(computedValue.value)) {
+        return;
+      }
+      const startTime = computedValue.value[0];
+      const endTime = computedValue.value[1];
+      if (startTime && endTime) {
+        if (!isValidTimeRange(startTime, endTime, format.value)) {
+          computedValue.value = computedValue.value.reverse();
+        }
+        return;
+      }
+      computedValue.value = [];
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Trigger), mergeProps({
+        "popup-visible": unref(computedVisible),
+        position: _ctx.position,
+        "popup-container": unref(popupContainer),
+        "popup-offset": 4,
+        "unmount-on-close": _ctx.unmountOnClose,
+        disabled: unref(disabled) || unref(readonly),
+        "on-click-out-side": handleClickOutSide,
+        "auto-fit-popup-min-width": false,
+        "auto-fit-popup-width": false,
+        trigger: "click",
+        "animation-name": "slide-dynamic-origin",
+        "prevent-focus": ""
+      }, _ctx.triggerProps), {
+        content: withCtx(() => [
+          createVNode(TimePickerPanel, {
+            ref_key: "panelRef",
+            ref: panelRef
+          }, createSlots({ _: 2 }, [
+            _ctx.$slots.extra ? {
+              name: "extra",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "extra", {}, void 0, true)
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1536)
+        ]),
+        default: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass([
+              "yc-picker",
+              `yc-picker-size-${unref(size)}`,
+              _ctx.$attrs.class,
+              {
+                "yc-picker-disabled": unref(disabled),
+                "yc-picker-error": _ctx.error,
+                "yc-picker-focus": unref(computedVisible),
+                "yc-picker-has-prefix": _ctx.$slots.prefix,
+                "yc-picker-allow-clear": unref(showClearBtn)
+              }
+            ]),
+            style: normalizeStyle({
+              ..._ctx.$attrs.style || {}
+            })
+          }, [
+            _ctx.$slots.prefix ? (openBlock(), createElementBlock("div", _hoisted_1, [
+              renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
+            ])) : createCommentVNode("", true),
+            createElementVNode("div", {
+              class: normalizeClass([
+                "yc-picker-input",
+                {
+                  "yc-picker-input-active": !unref(curIndex) && unref(computedVisible)
+                }
+              ]),
+              onClick: _cache[0] || (_cache[0] = withModifiers(($event) => handleOpenPicker(0), ["stop"]))
+            }, [
+              createElementVNode("input", {
+                value: unref(isArray)(unref(computedValue)) ? unref(computedValue)[0] : unref(computedValue),
+                placeholder: unref(isArray)(_ctx.placeholder) ? _ctx.placeholder[0] : _ctx.placeholder,
+                disabled: unref(disabled),
+                readonly: unref(readonly),
+                ref: (el) => unref(inputRefs)[0] = el,
+                class: "yc-picker-start-time"
+              }, null, 8, _hoisted_2)
+            ], 2),
+            unref(type) == "time-range" ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+              _cache[2] || (_cache[2] = createElementVNode("span", { class: "yc-picker-separator" }, " - ", -1)),
+              createElementVNode("div", {
+                class: normalizeClass([
+                  "yc-picker-input",
+                  {
+                    "yc-picker-input-active": unref(curIndex) && unref(computedVisible)
+                  }
+                ]),
+                onClick: _cache[1] || (_cache[1] = withModifiers(($event) => handleOpenPicker(1), ["stop"]))
+              }, [
+                createElementVNode("input", {
+                  value: unref(isArray)(unref(computedValue)) ? unref(computedValue)[1] : unref(computedValue),
+                  placeholder: unref(isArray)(_ctx.placeholder) ? _ctx.placeholder[1] : _ctx.placeholder,
+                  disabled: unref(disabled),
+                  readonly: unref(readonly),
+                  ref: (el) => unref(inputRefs)[1] = el,
+                  class: "yc-picker-start-time"
+                }, null, 8, _hoisted_3)
+              ], 2)
+            ], 64)) : createCommentVNode("", true),
+            createElementVNode("div", _hoisted_4, [
+              unref(showClearBtn) ? (openBlock(), createBlock(unref(IconButton), {
+                key: 0,
+                size: 14,
+                class: "yc-picker-clear-icon",
+                onClick: handleClear
+              })) : createCommentVNode("", true),
+              createElementVNode("span", _hoisted_5, [
+                renderSlot(_ctx.$slots, "suffix-icon", {}, () => [
+                  createVNode(unref(_sfc_main$1))
+                ], true)
+              ])
+            ])
+          ], 6)
+        ]),
+        _: 3
+      }, 16, ["popup-visible", "position", "popup-container", "unmount-on-close", "disabled"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/TimePicker/TimePickerPanel.vue.d.ts

@@ -0,0 +1,19 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        extra?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    scroll(value: string): Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/TimePicker/TimePickerPanel.vue.js

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

package/es/TimePicker/TimePickerPanel.vue2.js

@@ -0,0 +1,218 @@
+import { defineComponent, ref, computed, createElementBlock, openBlock, createElementVNode, createCommentVNode, Fragment, renderList, unref, createVNode, withCtx, withDirectives, normalizeClass, toDisplayString, vShow, renderSlot, createTextVNode } from "vue";
+import Tween from "../node_modules/b-tween/dist/b-tween.es.js";
+import dayjs from "../node_modules/dayjs/dayjs.min.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { sleep } from "../_shared/utils/fn.js";
+import { isUndefined, isArray } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useContext from "./hooks/useContext.js";
+import Button from "../Button/index.js";
+import Scrollbar from "../Scrollbar/index.js";
+const _hoisted_1 = { class: "yc-timepicker-container" };
+const _hoisted_2 = { class: "yc-timepicker" };
+const _hoisted_3 = ["onClick"];
+const _hoisted_4 = { class: "yc-timepicker-cell-inner" };
+const _hoisted_5 = {
+  key: 0,
+  class: "yc-timepicker-footer-extra-wrapper"
+};
+const _hoisted_6 = {
+  key: 1,
+  class: "yc-timepicker-footer-btn-wrapper"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TimePickerPanel",
+  setup(__props, { expose: __expose }) {
+    const {
+      timeColumn,
+      timeColumnCells,
+      curValue,
+      format,
+      computedValue,
+      computedVisible,
+      disableConfirm,
+      hideDisabledOptions,
+      curIndex,
+      inputRefs,
+      disabledHours,
+      disabledMinutes,
+      disabledSeconds
+    } = useContext().inject();
+    const scrollRefs = ref([]);
+    const disabled = computed(() => {
+      return !curValue.value.length || curValue.value.some((val) => !`${val}`);
+    });
+    const disabledTime = (value, unit) => {
+      var _a, _b, _c;
+      if (unit == "hour") {
+        return (_a = disabledHours == null ? void 0 : disabledHours()) == null ? void 0 : _a.includes(value);
+      } else if (unit == "minute") {
+        return (_b = disabledMinutes == null ? void 0 : disabledMinutes(...curValue.value)) == null ? void 0 : _b.includes(value);
+      } else {
+        return (_c = disabledSeconds == null ? void 0 : disabledSeconds(...curValue.value)) == null ? void 0 : _c.includes(value);
+      }
+    };
+    const handleClick = (val, i, target) => {
+      curValue.value[i] = val;
+      timeColumn.value.forEach((_, i1) => {
+        curValue.value[i1] = isUndefined(curValue.value[i1]) ? 0 : curValue.value[i1];
+      });
+      const scrollContainer = scrollRefs.value[i].getScrollRef();
+      new Tween({
+        from: { scroll: scrollContainer.scrollTop },
+        to: { scroll: target.offsetTop },
+        duration: 300,
+        easing: "quadOut",
+        onUpdate: (current) => {
+          scrollContainer.scrollTo({
+            top: current.scroll,
+            behavior: "instant"
+          });
+        }
+      }).start();
+      if (!disableConfirm.value) {
+        return;
+      }
+      handleConfirm();
+    };
+    const hanldeJump = (timeMap) => {
+      const cells = scrollRefs.value.map((el) => {
+        return el.getScrollRef().querySelectorAll(".yc-timepicker-cell");
+      });
+      timeColumn.value.map((v, i) => {
+        const time = timeMap[v];
+        handleClick(time, i, Array.from(cells[i])[time]);
+      });
+    };
+    const handleConfirm = () => {
+      var _a;
+      let date = dayjs();
+      timeColumn.value.forEach((v, i) => {
+        date = date.set(v, curValue.value[i]);
+      });
+      const formatValue = date.format(format.value);
+      if (!isArray(computedValue.value)) {
+        computedVisible.value = false;
+        computedValue.value = formatValue;
+      } else {
+        computedValue.value[curIndex.value] = formatValue;
+        if (disableConfirm.value) {
+          return;
+        }
+        if (curIndex.value || computedValue.value[curIndex.value + 1]) {
+          return computedVisible.value = false;
+        }
+        curIndex.value++;
+        (_a = inputRefs.value[curIndex.value]) == null ? void 0 : _a.focus();
+        curValue.value = [];
+      }
+    };
+    __expose({
+      async scroll(value) {
+        if (!computedVisible.value || !value) return;
+        await sleep(0);
+        const date = dayjs(value, format.value);
+        const timeMap = {
+          hour: date.hour(),
+          minute: date.minute(),
+          second: date.second()
+        };
+        curValue.value = timeColumn.value.map((v) => timeMap[v]);
+        hanldeJump(timeMap);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(timeColumnCells), (column, i) => {
+            return openBlock(), createElementBlock("div", {
+              key: i,
+              class: "yc-timepicker-column"
+            }, [
+              createVNode(unref(Scrollbar), {
+                "outer-style": {
+                  height: "100%"
+                },
+                style: {
+                  height: "100%",
+                  overflow: "auto"
+                },
+                ref_for: true,
+                ref: (el) => scrollRefs.value[i] = el
+              }, {
+                default: withCtx(() => [
+                  createElementVNode("ul", null, [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(column.cells, (cell) => {
+                      return withDirectives((openBlock(), createElementBlock("li", {
+                        key: cell.value,
+                        class: normalizeClass([
+                          "yc-timepicker-cell",
+                          {
+                            "yc-timepicker-cell-selected": cell.value == unref(curValue)[i],
+                            "yc-timepicker-cell-disabled": disabledTime(
+                              cell.value,
+                              column.unit
+                            )
+                          }
+                        ]),
+                        onClick: ($event) => !disabledTime(cell.value, column.unit) && handleClick(cell.value, i, $event.target)
+                      }, [
+                        createElementVNode("div", _hoisted_4, toDisplayString(cell.label), 1)
+                      ], 10, _hoisted_3)), [
+                        [
+                          vShow,
+                          !unref(hideDisabledOptions) || !disabledTime(cell.value, column.unit)
+                        ]
+                      ]);
+                    }), 128))
+                  ])
+                ]),
+                _: 2
+              }, 1536)
+            ]);
+          }), 128))
+        ]),
+        _ctx.$slots.extra ? (openBlock(), createElementBlock("div", _hoisted_5, [
+          renderSlot(_ctx.$slots, "extra", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        !unref(disableConfirm) ? (openBlock(), createElementBlock("div", _hoisted_6, [
+          createVNode(unref(Button), {
+            size: "mini",
+            onClick: _cache[0] || (_cache[0] = () => {
+              const date = /* @__PURE__ */ new Date();
+              hanldeJump({
+                hour: date.getHours(),
+                minute: date.getMinutes(),
+                second: date.getSeconds()
+              });
+            })
+          }, {
+            default: withCtx(() => _cache[1] || (_cache[1] = [
+              createTextVNode("此刻", -1)
+            ])),
+            _: 1,
+            __: [1]
+          }),
+          createVNode(unref(Button), {
+            type: "primary",
+            size: "mini",
+            disabled: disabled.value,
+            onClick: handleConfirm
+          }, {
+            default: withCtx(() => _cache[2] || (_cache[2] = [
+              createTextVNode(" 确定 ", -1)
+            ])),
+            _: 1,
+            __: [2]
+          }, 8, ["disabled"])
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

@@ -0,0 +1,42 @@
+import { Ref } from 'vue';
+import { TimePickerEmits, TimePickerType, TimePickerValue, TimeUnit, DisabledHours, DisabledMinutes, DisabledSeconds } from '../type';
+import { Props } from '../../_shared/type';
+type TimePickerContext = {
+    type: Ref<TimePickerType>;
+    format: Ref<string>;
+    computedValue: Ref<TimePickerValue>;
+    computedVisible: Ref<boolean>;
+    curIndex: Ref<number>;
+    curValue: Ref<number[]>;
+    timeColumn: Ref<TimeUnit[]>;
+    timeColumnCells: Ref<{
+        unit: TimeUnit;
+        cells: TimePickerCell[];
+    }[]>;
+    inputRefs: Ref<HTMLInputElement[]>;
+    disableConfirm: Ref<boolean>;
+    hideDisabledOptions: Ref<boolean>;
+    disabledHours: DisabledHours;
+    disabledMinutes: DisabledMinutes;
+    disabledSeconds: DisabledSeconds;
+};
+type TimePickerCell = {
+    label: string;
+    value: number;
+};
+declare const _default: () => {
+    provide: (props: Props, emits: TimePickerEmits) => {
+        computedValue: import('vue').WritableComputedRef<any, TimePickerValue>;
+        computedVisible: import('vue').WritableComputedRef<any, boolean>;
+        showClearBtn: import('vue').ComputedRef<any>;
+        curValue: Ref<number[], number[]>;
+        readonly: Ref<boolean, boolean>;
+        disabled: Ref<boolean, boolean>;
+        type: Ref<TimePickerType, TimePickerType>;
+        curIndex: Ref<number, number>;
+        inputRefs: Ref<HTMLInputElement[], HTMLInputElement[]>;
+        format: Ref<string, string>;
+    };
+    inject: () => TimePickerContext;
+};
+export default _default;