yc-design-vue 1.7.6 → 1.7.8

package/es/Textarea/index.vue.js

@@ -1,7 +1,165 @@
-import _sfc_main from "./index.vue2.js";
-/* empty css           */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Textarea = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-410cecd1"]]);
+import { defineComponent, toRefs, ref, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, createElementVNode, createBlock, toDisplayString, normalizeStyle, withCtx, createTextVNode } from "vue";
+import useTextareaHeight from "./hooks/useTextareaHeight.js";
+import useLimitedInput from "../Input/hooks/useLimitedInput.js";
+import _sfc_main$2 from "../_shared/components/IconButton.vue.js";
+/* empty css                                    */
+import _sfc_main$1 from "../_shared/components/PreventFocus.vue.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+/* empty css                                         */
+const _hoisted_1 = ["value", "disabled", "readonly", "placeholder"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Textarea"
+  },
+  __name: "index",
+  props: {
+    modelValue: { default: void 0 },
+    defaultValue: { default: "" },
+    placeholder: { default: "" },
+    disabled: { type: Boolean, default: false },
+    error: { type: [Boolean, Object], default: void 0 },
+    maxLength: { default: void 0 },
+    showWordLimit: { type: Boolean, default: false },
+    allowClear: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    autoSize: { type: [Boolean, Object], default: false },
+    wordLength: { type: Function, default: (value) => {
+      return value.length;
+    } },
+    wordSlice: { type: Function, default: (value, maxLength) => {
+      return value.slice(0, maxLength);
+    } },
+    enterPrevent: { type: Boolean, default: false },
+    showMirror: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "input", "change", "clear", "focus", "blur", "keydown"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { autoSize } = toRefs(props);
+    const inputRef = ref();
+    const mirrorRef = ref();
+    const {
+      error,
+      computedValue,
+      showWordLimit,
+      showClearBtn,
+      curLength,
+      maxLength,
+      handleInput,
+      handleComposition
+    } = useLimitedInput({
+      props,
+      emits,
+      inputRef
+    });
+    const { style } = useTextareaHeight(mirrorRef, autoSize.value);
+    const handleEvent = async (type, e) => {
+      switch (type) {
+        case "input":
+          {
+            handleInput(e);
+          }
+          break;
+        case "change":
+          {
+            emits("change", computedValue.value, e);
+          }
+          break;
+        case "focus":
+        case "blur":
+          {
+            emits(type, e);
+          }
+          break;
+        case "clear":
+          {
+            computedValue.value = "";
+            emits("clear", e);
+          }
+          break;
+      }
+    };
+    __expose({
+      getInputRef() {
+        return inputRef.value;
+      },
+      getMirrorRef() {
+        return mirrorRef.value;
+      },
+      focus() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      },
+      blur() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.blur();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-textarea-wrapper",
+          {
+            "yc-textarea-disabled": _ctx.disabled,
+            "yc-textarea-error": unref(error),
+            "yc-textarea-auto-size": unref(autoSize)
+          }
+        ])
+      }, [
+        unref(autoSize) || _ctx.showMirror ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: "yc-textarea-mirror",
+          ref_key: "mirrorRef",
+          ref: mirrorRef
+        }, toDisplayString(unref(computedValue)), 513)) : createCommentVNode("", true),
+        createElementVNode("textarea", {
+          value: unref(computedValue),
+          disabled: _ctx.disabled,
+          readonly: _ctx.readonly,
+          placeholder: _ctx.placeholder,
+          style: normalizeStyle(unref(style)),
+          class: "yc-textarea",
+          ref_key: "inputRef",
+          ref: inputRef,
+          onCompositionstart: _cache[0] || (_cache[0] = //@ts-ignore
+          (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
+          onCompositionupdate: _cache[1] || (_cache[1] = //@ts-ignore
+          (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
+          onCompositionend: _cache[2] || (_cache[2] = //@ts-ignore
+          (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
+          onKeydown: _cache[3] || (_cache[3] = (ev) => {
+            ev.key == "Enter" && _ctx.enterPrevent && ev.preventDefault();
+            _ctx.$emit("keydown", ev);
+          }),
+          onInput: _cache[4] || (_cache[4] = ($event) => handleEvent("input", $event)),
+          onChange: _cache[5] || (_cache[5] = ($event) => handleEvent("change", $event)),
+          onFocus: _cache[6] || (_cache[6] = ($event) => handleEvent("focus", $event)),
+          onBlur: _cache[7] || (_cache[7] = ($event) => handleEvent("blur", $event))
+        }, null, 44, _hoisted_1),
+        unref(showWordLimit) ? (openBlock(), createBlock(unref(_sfc_main$1), {
+          key: 1,
+          tag: "span",
+          class: "yc-textarea-word-limit"
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(unref(curLength)) + " / " + toDisplayString(unref(maxLength)), 1)
+          ]),
+          _: 1
+        })) : createCommentVNode("", true),
+        unref(showClearBtn) ? (openBlock(), createBlock(unref(_sfc_main$2), {
+          key: 2,
+          class: "yc-textarea-clear-button",
+          onClick: _cache[8] || (_cache[8] = ($event) => handleEvent("clear", $event))
+        })) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
 export {
-  _Textarea as default
+  _sfc_main as default
 };

package/es/Textarea/index.vue3.js

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

package/es/TimePicker/TimePicker.vue.js

@@ -1,7 +1,216 @@
-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-9dcac810"]]);
+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 _sfc_main$1 from "../_shared/components/IconButton.vue.js";
+/* empty css                                    */
+/* empty css                                         */
+/* empty css                             */
+import _sfc_main$2 from "../_shared/icons/IconTime.vue.js";
+import Trigger from "../Trigger/index.js";
+import _sfc_main$3 from "./TimePickerPanel.vue.js";
+/* empty css                     */
+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(_sfc_main$3, {
+            ref_key: "panelRef",
+            ref: panelRef
+          }, createSlots({ _: 2 }, [
+            _ctx.$slots.extra ? {
+              name: "extra",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "extra")
+              ]),
+              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),
+                "yc-picker-range": unref(type) == "time-range"
+              }
+            ]),
+            style: normalizeStyle({
+              ..._ctx.$attrs.style || {}
+            })
+          }, [
+            _ctx.$slots.prefix ? (openBlock(), createElementBlock("div", _hoisted_1, [
+              renderSlot(_ctx.$slots, "prefix")
+            ])) : 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(_sfc_main$1), {
+                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$2))
+                ])
+              ])
+            ])
+          ], 6)
+        ]),
+        _: 3
+      }, 16, ["popup-visible", "position", "popup-container", "unmount-on-close", "disabled"]);
+    };
+  }
+});
 export {
-  _TimePicker as default
+  _sfc_main as default
 };

package/es/TimePicker/TimePicker.vue3.js

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

package/es/TimePicker/TimePickerPanel.vue.js

@@ -1,7 +1,217 @@
-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"]]);
+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 { sleep } from "../_shared/utils/dom.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")
+        ])) : 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 {
-  TimePickerPanel as default
+  _sfc_main as default
 };

package/es/TimePicker/TimePickerPanel.vue3.js

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

package/es/TimePicker/index.js

@@ -1,7 +1,8 @@
-import _TimePicker from "./TimePicker.vue.js";
-const TimePicker = Object.assign(_TimePicker, {
+import _sfc_main from "./TimePicker.vue.js";
+/* empty css                */
+const TimePicker = Object.assign(_sfc_main, {
   install: (app) => {
-    app.component("Yc" + _TimePicker.name, _TimePicker);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
   }
 });
 export {