@voicenter-team/voicenter-ui-plus 2.0.10 → 3.0.0

package/library/components/VcTag/VcTag.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./VcTag.vue.mjs";
+import '../../assets/components/VcTag/VcTag.css';/* empty css            */
+export {
+  _sfc_main as default
+};

package/library/components/VcTagInput/VcTagInput.vue.mjs

@@ -0,0 +1,294 @@
+import '../../assets/components/VcTagInput/VcTagInput.css';
+import { defineComponent, ref, computed, openBlock, createElementBlock, normalizeStyle, normalizeClass, createElementVNode, createVNode, unref, createCommentVNode, Fragment, renderList, mergeProps, createBlock } from "vue";
+import _sfc_main$2 from "../VcTag/VcTag.vue.mjs";
+import '../../assets/components/VcIcon/VcIcon.css';import '../../assets/components/VcTag/VcTag.css';/* empty css                   */
+import _sfc_main$1 from "../VcIcon/VcIcon.vue.mjs";
+/* empty css                     */
+import useInputBase from "../../composables/input/useInputBase.mjs";
+const _hoisted_1 = {
+  key: 0,
+  class: "vc-tag-input__prefix-icon"
+};
+const _hoisted_2 = { class: "vc-tag-input__tags flex flex-wrap" };
+const _hoisted_3 = { class: "vc-tag-input__input-token" };
+const _hoisted_4 = ["data-test", "disabled"];
+const _hoisted_5 = {
+  key: 1,
+  class: "vc-tag-input__clearable"
+};
+const CLASS_FOR_COLOR = "vc-tag-input-color--";
+const CLASS_FOR_ICON_COLOR = "vc-tag-input-icon-color--";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "VcTagInput",
+  props: {
+    modelValue: { default: () => [] },
+    clearable: { type: Boolean, default: false },
+    addOnBlur: { type: Boolean, default: false },
+    allowDuplicate: { type: Boolean, default: true },
+    tagBorderless: { type: Boolean, default: false },
+    tagSquare: { type: Boolean, default: false },
+    compact: { type: Boolean, default: false },
+    max: { default: void 0 },
+    separator: { default: void 0 },
+    class: { default: "" },
+    style: { type: [Boolean, null, String, Object, Array], default: void 0 },
+    tagColor: { default: "primary" },
+    tagMaxContent: { default: void 0 },
+    valueType: { default: "string" },
+    id: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    isError: { type: Boolean, default: false },
+    emptyText: {},
+    prefixIcon: { default: "" },
+    dataTestName: { default: "default" },
+    prefixIconSize: { default: "sm" },
+    name: { default: "" },
+    placeholder: {},
+    maxWidth: {},
+    prefixIconColor: { default: "" },
+    color: { default: "active" }
+  },
+  emits: ["update:modelValue", "add", "remove"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { prefixClasses, prefixStyle, prefixIcon: resolvedPrefixIcon } = useInputBase(props, {
+      colorClass: CLASS_FOR_COLOR,
+      iconColorClass: CLASS_FOR_ICON_COLOR
+    });
+    const inputValue = ref("");
+    const focused = ref(false);
+    const tagInput = ref();
+    const hasDisabled = computed(() => {
+      return props.disabled || maxedOut.value;
+    });
+    const inputClasses = computed(() => {
+      const colorClass = props.color ? CLASS_FOR_COLOR + props.color : "";
+      return [
+        colorClass
+      ];
+    });
+    const maxedOut = computed(() => {
+      var _a;
+      return !!(props.max && ((_a = props.modelValue) == null ? void 0 : _a.length) && props.max === props.modelValue.length);
+    });
+    const containerClass = computed(() => {
+      return [props.class, {
+        "vc-tag-input__wrap--filled": !!(props.modelValue && props.modelValue.length || inputValue.value && inputValue.value.length),
+        "vc-tag-input__wrap--focus": focused.value,
+        "vc-tag-input__wrap--error": props.isError,
+        "vc-tag-input__wrap--disabled": hasDisabled.value,
+        "is--compact": props.compact
+      }];
+    });
+    function clear() {
+      inputValue.value = "";
+      if (tagInput.value) {
+        tagInput.value.value = "";
+      }
+      emit("update:modelValue", []);
+    }
+    function removeTag(evt, index) {
+      removeItem(evt, index);
+    }
+    function onFocus() {
+      focused.value = true;
+    }
+    function onBlur(event) {
+      focused.value = false;
+      if (props.addOnBlur && event.target instanceof HTMLInputElement) {
+        addItem(event, event.target.value, false);
+      }
+    }
+    function formatItem(value) {
+      return props.valueType === "number" ? +value : `${value}`;
+    }
+    function addItem(event, item, preventDefault) {
+      if (item && item.trim().length) {
+        const value = props.modelValue ? [...props.modelValue] : [];
+        if (props.allowDuplicate || value.indexOf(item) === -1) {
+          value.push(formatItem(item));
+          updateModel(event, value, preventDefault);
+        }
+      }
+    }
+    function updateModel(event, value, preventDefault) {
+      emit("update:modelValue", value);
+      emit("add", {
+        originalEvent: event,
+        value
+      });
+      if (tagInput.value) {
+        tagInput.value.value = "";
+      }
+      inputValue.value = "";
+      if (preventDefault) {
+        event.preventDefault();
+      }
+    }
+    function onWrapperClick() {
+      var _a;
+      (_a = tagInput.value) == null ? void 0 : _a.focus();
+    }
+    function onInput(event) {
+      if (!(event.target instanceof HTMLInputElement)) {
+        return;
+      }
+      inputValue.value = event.target.value;
+    }
+    function onKeyDown(event) {
+      if (!(event.target instanceof HTMLInputElement)) {
+        return;
+      }
+      const inputValue2 = event.target.value;
+      switch (event.key) {
+        case "Backspace":
+          handleBackspace(event, inputValue2);
+          break;
+        case "Enter":
+          handleEnterKey(event, inputValue2);
+          break;
+        default:
+          handleSeparatorKey(event, inputValue2);
+          break;
+      }
+    }
+    function handleBackspace(event, inputValue2) {
+      var _a;
+      if (inputValue2.length === 0 && ((_a = props.modelValue) == null ? void 0 : _a.length) > 0) {
+        removeItem(event, props.modelValue.length - 1);
+      }
+    }
+    function handleEnterKey(event, inputValue2) {
+      if ((inputValue2 == null ? void 0 : inputValue2.trim().length) && !maxedOut.value) {
+        addItem(event, inputValue2, true);
+      }
+    }
+    function handleSeparatorKey(event, inputValue2) {
+      if (!props.separator) return;
+      const isSeparatorKey = Array.isArray(props.separator) ? props.separator.includes(event.key) : props.separator === event.key;
+      if (isSeparatorKey && inputValue2) {
+        addItem(event, inputValue2, true);
+      }
+    }
+    function removeItem(event, index) {
+      if (props.disabled) {
+        return;
+      }
+      const values = [...props.modelValue];
+      const removedItem = values.splice(index, 1);
+      emit("update:modelValue", values);
+      emit("remove", {
+        originalEvent: event,
+        value: removedItem
+      });
+    }
+    function onPaste(event) {
+      if (!props.separator) {
+        return;
+      }
+      const clipboardData = event.clipboardData;
+      if (!clipboardData) {
+        return;
+      }
+      const pastedData = clipboardData.getData("Text");
+      if (!pastedData) {
+        return;
+      }
+      const existing = props.modelValue || [];
+      const splitter = Array.isArray(props.separator) ? new RegExp(props.separator.map((s) => s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")) : props.separator;
+      const pastedValues = pastedData.split(splitter).filter((val) => props.allowDuplicate || existing.indexOf(val) === -1);
+      const value = [...existing, ...pastedValues].map((i) => formatItem(i));
+      updateModel(event, value, true);
+    }
+    __expose({
+      inputValue,
+      clear,
+      removeItem,
+      disabled: computed(() => props.disabled),
+      isError: computed(() => props.isError),
+      color: computed(() => props.color)
+    });
+    return (_ctx, _cache) => {
+      var _a;
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([containerClass.value, "vc-tag-input__wrap"]),
+        style: normalizeStyle(__props.style)
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass([[
+            ...inputClasses.value,
+            {
+              "is-clearable": __props.clearable,
+              "is-prefix-icon": __props.prefixIcon,
+              "is-error": __props.isError,
+              "is-disabled": hasDisabled.value
+            }
+          ], "vc-tag-input__container"])
+        }, [
+          __props.prefixIcon ? (openBlock(), createElementBlock("div", _hoisted_1, [
+            createVNode(_sfc_main$1, {
+              icon: unref(resolvedPrefixIcon),
+              class: normalizeClass(unref(prefixClasses)),
+              style: normalizeStyle(unref(prefixStyle))
+            }, null, 8, ["icon", "class", "style"])
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", {
+            class: "vc-tag-input__content",
+            onClick: onWrapperClick
+          }, [
+            createElementVNode("div", _hoisted_2, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.modelValue, (item, index) => {
+                return openBlock(), createElementBlock("div", {
+                  key: `tag-${item}-${index}`,
+                  class: "vc-tag-input__tag-item"
+                }, [
+                  createVNode(_sfc_main$2, {
+                    label: `${item}`,
+                    color: __props.tagColor,
+                    "max-content": __props.tagMaxContent,
+                    borderless: __props.tagBorderless,
+                    square: __props.tagSquare,
+                    compact: __props.compact,
+                    closable: "",
+                    class: normalizeClass({ "leading-1": __props.compact }),
+                    onOnClose: ($event) => removeTag($event, index)
+                  }, null, 8, ["label", "color", "max-content", "borderless", "square", "compact", "class", "onOnClose"])
+                ]);
+              }), 128)),
+              createElementVNode("div", _hoisted_3, [
+                createElementVNode("input", mergeProps({
+                  ref_key: "tagInput",
+                  ref: tagInput,
+                  "data-test": __props.dataTestName,
+                  type: "text",
+                  class: "vc-tag-input__input",
+                  disabled: hasDisabled.value
+                }, _ctx.$attrs, {
+                  onFocus,
+                  onBlur: _cache[0] || (_cache[0] = ($event) => onBlur($event)),
+                  onInput,
+                  onKeydown: _cache[1] || (_cache[1] = ($event) => onKeyDown($event)),
+                  onPaste: _cache[2] || (_cache[2] = ($event) => onPaste($event))
+                }), null, 16, _hoisted_4)
+              ])
+            ])
+          ]),
+          __props.clearable ? (openBlock(), createElementBlock("div", _hoisted_5, [
+            ((_a = __props.modelValue) == null ? void 0 : _a.length) ? (openBlock(), createBlock(_sfc_main$1, {
+              key: 0,
+              icon: "vc-icon-close icon-xxs",
+              onClick: clear
+            })) : createCommentVNode("", true)
+          ])) : createCommentVNode("", true)
+        ], 2)
+      ], 6);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/library/components/VcTagInput/VcTagInput.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./VcTagInput.vue.mjs";
+import '../../assets/components/VcTagInput/VcTagInput.css';/* empty css                 */
+export {
+  _sfc_main as default
+};

package/library/components/VcTimeInput/VcTimeInput.vue.mjs

@@ -0,0 +1,357 @@
+import '../../assets/components/VcTimeInput/VcTimeInput.css';
+import { defineComponent, ref, reactive, computed, watch, onMounted, openBlock, createElementBlock, normalizeStyle, unref, createElementVNode, normalizeClass, withDirectives, toDisplayString, createCommentVNode, withModifiers, vModelText } from "vue";
+import { longPress } from "../../directives/long-press.mjs";
+import useInputBase from "../../composables/input/useInputBase.mjs";
+const _hoisted_1 = ["data-test"];
+const _hoisted_2 = {
+  class: "vc-time-input__input-wrapper",
+  "data-test": "time-input-container"
+};
+const _hoisted_3 = ["disabled"];
+const _hoisted_4 = { class: "divider-wrapper" };
+const _hoisted_5 = { class: "divider" };
+const _hoisted_6 = ["disabled"];
+const _hoisted_7 = { class: "divider-wrapper" };
+const _hoisted_8 = { class: "divider" };
+const _hoisted_9 = ["disabled"];
+const CLASS_FOR_COLOR = "vc-time-input-color--";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "VcTimeInput",
+  props: {
+    modelValue: { default: void 0 },
+    step: { default: 1 },
+    minValue: { default: 0 },
+    maxValue: { default: 86400 },
+    dataTestName: { default: "default" },
+    divider: { default: ":" },
+    emptyDataText: { default: "" },
+    placeholder: { default: "" },
+    allowMouseWheel: { type: Boolean, default: false },
+    id: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    clearable: { type: Boolean },
+    isError: { type: Boolean, default: false },
+    emptyText: {},
+    prefixIcon: {},
+    prefixIconSize: {},
+    name: { default: void 0 },
+    maxWidth: {},
+    prefixIconColor: {},
+    color: { default: "active" }
+  },
+  emits: ["input", "update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const vLongPress = { ...longPress };
+    const props = __props;
+    const emit = __emit;
+    const { maxWidthStyle, inputClasses } = useInputBase(props, {
+      colorClass: CLASS_FOR_COLOR
+    });
+    const isFocus = ref(false);
+    const timeSettingModel = reactive({
+      hours: "0",
+      minutes: "0",
+      seconds: "0"
+    });
+    const hours = ref();
+    const minutes = ref();
+    const seconds = ref();
+    const timeModel = computed(() => {
+      return props.modelValue || 0;
+    });
+    const disabledDecreaseBtn = computed(() => {
+      const _time = timeModel.value;
+      return _time <= props.minValue || props.disabled;
+    });
+    const disabledIncreaseBtn = computed(() => {
+      const _time = timeModel.value;
+      return props.maxValue !== 0 && _time >= props.maxValue || props.disabled;
+    });
+    const hideInputs = computed(() => {
+      const _time = props.modelValue || timeModel.value;
+      return !!(!isFocus.value && _time === 0 && props.emptyDataText);
+    });
+    const placeholderInput = computed(() => {
+      return props.emptyDataText || props.placeholder || "00:00:00";
+    });
+    function onClickWrapper() {
+      onClickInput("seconds");
+    }
+    const onLongPressDecrease = () => {
+      return decrease();
+    };
+    const onLongPressIncrease = () => {
+      return increase();
+    };
+    function onWheelMouse(event) {
+      if (props.allowMouseWheel) {
+        event.preventDefault();
+        if (event.deltaY < 0) {
+          increase();
+        } else if (event.deltaY > 0) {
+          decrease();
+        }
+      }
+    }
+    function getSecondsOfTime(time) {
+      const { hours: hours2, minutes: minutes2, seconds: seconds2 } = time;
+      return parseInt(hours2) * 3600 + parseInt(minutes2) * 60 + parseInt(seconds2);
+    }
+    function onPlaceholderClick() {
+      onClickInput("seconds");
+    }
+    function onClickInput(type) {
+      var _a, _b, _c;
+      switch (type) {
+        case "hours":
+          (_a = hours.value) == null ? void 0 : _a.select();
+          break;
+        case "minutes":
+          (_b = minutes.value) == null ? void 0 : _b.select();
+          break;
+        case "seconds":
+          (_c = seconds.value) == null ? void 0 : _c.select();
+          break;
+      }
+    }
+    function updateTimeInput(val, type) {
+      const correctValue = checkValue(val, type);
+      return setFormatValue(correctValue);
+    }
+    function checkValue(val, type) {
+      let timeValue = parseInt(val) || 0;
+      if (timeValue < 0) {
+        timeValue = 0;
+      }
+      if (["minutes", "seconds"].includes(type) && timeValue > 59) {
+        timeValue = 59;
+      }
+      return timeValue;
+    }
+    function setFormatValue(val) {
+      if (val < 10) {
+        return `0${val}`;
+      }
+      return `${val}`;
+    }
+    function getTimeData(value) {
+      const hours2 = Math.floor(value / 3600);
+      const minutes2 = Math.floor(value / 60 - hours2 * 60);
+      const seconds2 = Math.floor(value - hours2 * 3600 - minutes2 * 60);
+      return {
+        hours: hours2,
+        minutes: minutes2,
+        seconds: seconds2
+      };
+    }
+    function decrease() {
+      if (disabledDecreaseBtn.value) {
+        return;
+      }
+      let _nevTime = timeModel.value - props.step;
+      if (_nevTime <= 0) {
+        _nevTime = 0;
+      } else if (_nevTime < props.minValue) {
+        _nevTime = props.minValue;
+      }
+      setTimeData(_nevTime);
+    }
+    function increase() {
+      if (disabledIncreaseBtn.value) {
+        return;
+      }
+      let _nevTime = timeModel.value + props.step;
+      if (_nevTime >= props.maxValue) {
+        _nevTime = props.maxValue;
+      }
+      setTimeData(_nevTime);
+    }
+    function setTimeData(time) {
+      const _timeData = getTimeData(time);
+      timeSettingModel.hours = setFormatValue(_timeData.hours);
+      timeSettingModel.minutes = setFormatValue(_timeData.minutes);
+      timeSettingModel.seconds = setFormatValue(_timeData.seconds);
+    }
+    watch(
+      () => timeSettingModel.seconds,
+      (val) => {
+        timeSettingModel.seconds = updateTimeInput(val, "seconds");
+      },
+      {
+        immediate: true
+      }
+    );
+    watch(
+      () => timeSettingModel.minutes,
+      (val) => {
+        timeSettingModel.minutes = updateTimeInput(val, "minutes");
+      },
+      {
+        immediate: true
+      }
+    );
+    watch(
+      () => timeSettingModel.hours,
+      (val) => {
+        timeSettingModel.hours = updateTimeInput(val, "hours");
+      },
+      {
+        immediate: true
+      }
+    );
+    watch(
+      timeModel,
+      (val) => {
+        if (props.maxValue > 0 && val > props.maxValue) {
+          setTimeData(props.maxValue);
+        } else if (val < props.minValue) {
+          setTimeData(props.minValue);
+        } else {
+          setTimeData(val);
+        }
+      },
+      { immediate: true }
+    );
+    watch(
+      timeSettingModel,
+      (val) => {
+        const _seconds = getSecondsOfTime(val);
+        emit("update:modelValue", _seconds);
+        emit("input", {
+          seconds: _seconds,
+          string: val
+        });
+      },
+      { deep: true }
+    );
+    onMounted(() => {
+      if (timeModel.value < props.minValue) {
+        const res = {
+          seconds: props.minValue || 0,
+          string: { ...timeSettingModel }
+        };
+        emit("update:modelValue", props.minValue);
+        emit("input", res);
+      } else if (timeModel.value > props.maxValue) {
+        const res = {
+          seconds: props.maxValue || 0,
+          string: { ...timeSettingModel }
+        };
+        emit("update:modelValue", props.minValue);
+        emit("input", res);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        "data-test": __props.dataTestName,
+        style: normalizeStyle(unref(maxWidthStyle)),
+        class: "vc-time-input"
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass([[
+            unref(inputClasses),
+            {
+              "is-focused": isFocus.value,
+              "is-error": __props.isError,
+              "is-disabled": __props.disabled
+            }
+          ], "vc-time-input__container"]),
+          "data-test": "vc-time-input"
+        }, [
+          withDirectives((openBlock(), createElementBlock("div", {
+            class: normalizeClass(["vc-time-input__btn-decrease", {
+              "is-disabled": disabledDecreaseBtn.value
+            }]),
+            "data-test": "decrease-button",
+            onClick: decrease
+          }, [..._cache[12] || (_cache[12] = [
+            createElementVNode("i", { class: "vc-icon-minus-linear icon-base icon" }, null, -1)
+          ])], 2)), [
+            [vLongPress, { functionToCall: onLongPressDecrease, repeat: true }]
+          ]),
+          createElementVNode("div", _hoisted_2, [
+            hideInputs.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "vc-time-input__empty-placeholder",
+              onClick: onPlaceholderClick
+            }, toDisplayString(placeholderInput.value), 1)) : createCommentVNode("", true),
+            createElementVNode("div", {
+              class: "vc-time-input__times",
+              onClick: withModifiers(onClickWrapper, ["stop", "self"]),
+              onWheel: onWheelMouse
+            }, [
+              withDirectives(createElementVNode("input", {
+                ref_key: "hours",
+                ref: hours,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => timeSettingModel.hours = $event),
+                class: "vc-time-input__input hours",
+                type: "number",
+                "data-test": "hours",
+                disabled: __props.disabled,
+                placeholder: "00",
+                onFocusin: _cache[1] || (_cache[1] = ($event) => isFocus.value = true),
+                onFocusout: _cache[2] || (_cache[2] = ($event) => isFocus.value = false),
+                onClick: _cache[3] || (_cache[3] = ($event) => onClickInput("hours"))
+              }, null, 40, _hoisted_3), [
+                [vModelText, timeSettingModel.hours]
+              ]),
+              createElementVNode("div", _hoisted_4, [
+                createElementVNode("span", _hoisted_5, toDisplayString(__props.divider), 1)
+              ]),
+              withDirectives(createElementVNode("input", {
+                ref_key: "minutes",
+                ref: minutes,
+                "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => timeSettingModel.minutes = $event),
+                class: "vc-time-input__input minutes",
+                type: "number",
+                "data-test": "minutes",
+                disabled: __props.disabled,
+                placeholder: "00",
+                onFocusin: _cache[5] || (_cache[5] = ($event) => isFocus.value = true),
+                onFocusout: _cache[6] || (_cache[6] = ($event) => isFocus.value = false),
+                onClick: _cache[7] || (_cache[7] = ($event) => onClickInput("minutes"))
+              }, null, 40, _hoisted_6), [
+                [vModelText, timeSettingModel.minutes]
+              ]),
+              createElementVNode("div", _hoisted_7, [
+                createElementVNode("span", _hoisted_8, toDisplayString(__props.divider), 1)
+              ]),
+              withDirectives(createElementVNode("input", {
+                ref_key: "seconds",
+                ref: seconds,
+                "onUpdate:modelValue": _cache[8] || (_cache[8] = ($event) => timeSettingModel.seconds = $event),
+                class: "vc-time-input__input seconds",
+                type: "number",
+                "data-test": "seconds",
+                disabled: __props.disabled,
+                placeholder: "00",
+                onFocusin: _cache[9] || (_cache[9] = ($event) => isFocus.value = true),
+                onFocusout: _cache[10] || (_cache[10] = ($event) => isFocus.value = false),
+                onClick: _cache[11] || (_cache[11] = ($event) => onClickInput("seconds"))
+              }, null, 40, _hoisted_9), [
+                [vModelText, timeSettingModel.seconds]
+              ])
+            ], 32)
+          ]),
+          withDirectives((openBlock(), createElementBlock("div", {
+            class: normalizeClass(["vc-time-input__btn-increase", {
+              "is-disabled": disabledIncreaseBtn.value
+            }]),
+            "data-test": "increase-button",
+            onClick: increase
+          }, [..._cache[13] || (_cache[13] = [
+            createElementVNode("i", { class: "vc-icon-plus-linear icon-base icon" }, null, -1)
+          ])], 2)), [
+            [vLongPress, { functionToCall: onLongPressIncrease, repeat: true }]
+          ])
+        ], 2)
+      ], 12, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/library/components/VcTimeInput/VcTimeInput.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./VcTimeInput.vue.mjs";
+import '../../assets/components/VcTimeInput/VcTimeInput.css';/* empty css                  */
+export {
+  _sfc_main as default
+};