vue-devui 1.0.0-rc.0 → 1.0.0-rc.11

package/time-picker/index.es.js

@@ -1,1237 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-import { defineComponent, createVNode, reactive, ref, onMounted, onBeforeUnmount, onUnmounted, Fragment, h, render, computed, toRefs, withDirectives, resolveDirective, watch, createTextVNode } from "vue";
-const timePickerProps = {
-  modelValue: {
-    type: String,
-    default: ""
-  },
-  placeholder: {
-    type: String,
-    default: "00:00:00"
-  },
-  disabled: {
-    type: Boolean,
-    default: false
-  },
-  timePickerWidth: {
-    type: Number,
-    default: 212
-  },
-  minTime: {
-    type: String,
-    default: "00:00:00"
-  },
-  maxTime: {
-    type: String,
-    default: "23:59:59"
-  },
-  format: {
-    type: String,
-    default: "hh:mm:ss"
-  },
-  autoOpen: {
-    type: Boolean,
-    default: false
-  },
-  showAnimation: {
-    type: Boolean,
-    default: true
-  }
-};
-var Icon = defineComponent({
-  name: "DIcon",
-  props: {
-    name: {
-      type: String,
-      required: true
-    },
-    size: {
-      type: String,
-      default: "inherit"
-    },
-    color: {
-      type: String,
-      default: "inherit"
-    },
-    classPrefix: {
-      type: String,
-      default: "icon"
-    }
-  },
-  setup(props) {
-    return __spreadValues({}, props);
-  },
-  render() {
-    const {
-      name,
-      size,
-      color,
-      classPrefix
-    } = this;
-    return /^((https?):)?\/\//.test(name) ? createVNode("img", {
-      "src": name,
-      "alt": name.split("/")[name.split("/").length - 1],
-      "style": {
-        width: size,
-        verticalAlign: "text-bottom"
-      }
-    }, null) : createVNode("i", {
-      "class": `${classPrefix} ${classPrefix}-${name}`,
-      "style": {
-        fontSize: size,
-        color
-      }
-    }, null);
-  }
-});
-Icon.install = function(app) {
-  app.component(Icon.name, Icon);
-};
-function getPositionFun(el, left, top) {
-  const inputDom = el.getBoundingClientRect();
-  const button2 = window.innerHeight - (inputDom.top + 20);
-  if (button2 > inputDom.top + 20) {
-    left.value = inputDom.x;
-    top.value = inputDom.top + 20 + 10;
-  } else {
-    left.value = inputDom.x;
-    top.value = inputDom.top - 316;
-  }
-}
-function initializeTimeData(type) {
-  const timeArr = reactive([]);
-  let arrLenght = 0;
-  if (type == "hour") {
-    arrLenght = 24;
-  } else {
-    arrLenght = 60;
-  }
-  for (let i = 0; i < arrLenght; i++) {
-    timeArr.push({
-      time: i < 10 ? "0" + i : i + "",
-      isActive: false,
-      flag: type,
-      isDisabled: false
-    });
-  }
-  return timeArr;
-}
-const setTimeAstrict = (hourList, minuteList, secondList, minTime, maxTime, format) => {
-  const maxTimeHour = maxTime.split(":")[0];
-  const maxTimeMinute = maxTime.split(":")[1];
-  const minTimeHour = minTime.split(":")[0];
-  const minTimeMinute = minTime.split(":")[1];
-  const minTimeSecond = minTime.split(":")[2];
-  hourList.map((item, index2) => {
-    if (item.time < minTimeHour || item.time > maxTimeHour) {
-      item.isDisabled = true;
-    }
-  });
-  if (format == "mm:ss") {
-    minuteList.map((item, index2) => {
-      if (item.time < minTimeMinute || item.time > maxTimeMinute) {
-        item.isDisabled = true;
-      }
-    });
-  } else {
-    minuteList.map((item, index2) => {
-      if (item.time < minTimeMinute) {
-        item.isDisabled = true;
-      }
-    });
-  }
-  secondList.map((item, index2) => {
-    if (item.time < minTimeSecond) {
-      item.isDisabled = true;
-    }
-  });
-};
-function useTimePicker(hh, mm, ss, minTime, maxTime, format, autoOpen, disabled, value) {
-  const isActive = ref(false);
-  const showPopup = ref(false);
-  const devuiTimePicker = ref();
-  const inputDom = ref();
-  const left = ref(-100);
-  const top = ref(-100);
-  const timePopupDom = ref();
-  const timePickerValue = ref("");
-  const showClearIcon = ref(false);
-  const firsthandActiveTime = ref(`${hh.value}:${mm.value}:${ss.value}`);
-  const vModeValue = ref(value);
-  const getPopupPosition = () => {
-    getPositionFun(devuiTimePicker.value, left, top);
-  };
-  const clickVerifyFun = (e) => {
-    e.stopPropagation();
-    isActive.value = false;
-    showPopup.value = false;
-    if (disabled)
-      return;
-    const path = e.composedPath && e.composedPath() || e.path;
-    const inInputDom = path.includes(devuiTimePicker.value);
-    inInputDom && mouseInIputFun();
-  };
-  const mouseInIputFun = () => {
-    if (firsthandActiveTime.value == "00:00:00") {
-      const vModelValueArr = value.split(":");
-      const minTimeValueArr = minTime.split(":");
-      const maxTimeValueArr = maxTime.split(":");
-      vModeValue.value == "" ? vModeValue.value = "00:00:00" : "";
-      if (value > minTime && value < maxTime) {
-        firsthandActiveTime.value = value;
-        setInputValue(vModelValueArr[0], vModelValueArr[1], vModelValueArr[2]);
-      } else if (value > maxTime) {
-        firsthandActiveTime.value = maxTime;
-        setInputValue(maxTimeValueArr[0], maxTimeValueArr[1], maxTimeValueArr[2]);
-      } else {
-        firsthandActiveTime.value = minTime;
-        setInputValue(minTimeValueArr[0], minTimeValueArr[1], minTimeValueArr[2]);
-      }
-    }
-    isActive.value = true;
-    showPopup.value = true;
-  };
-  const vModelIsBeyond = () => {
-    if (vModeValue.value != "" && vModeValue.value < minTime) {
-      vModeValue.value = minTime;
-    } else if (vModeValue.value != "" && vModeValue.value > maxTime) {
-      vModeValue.value = maxTime;
-    }
-    const vModelValueArr = vModeValue.value.split(":");
-    vModeValue.value && setInputValue(vModelValueArr[0], vModelValueArr[1], vModelValueArr[2]);
-  };
-  const getTimeValue = (e) => {
-    e.stopPropagation();
-    if (showPopup.value) {
-      hh.value = timePopupDom.value.changTimeData().activeHour.value;
-      mm.value = timePopupDom.value.changTimeData().activeMinute.value;
-      ss.value = timePopupDom.value.changTimeData().activeSecond.value;
-      firsthandActiveTime.value = `${hh.value}:${mm.value}:${ss.value}`;
-      setInputValue(hh.value, mm.value, ss.value);
-    }
-  };
-  const setInputValue = (hh2, mm2, ss2) => {
-    if (format == "hh:mm:ss") {
-      vModeValue.value = `${hh2}:${mm2}:${ss2}`;
-    } else if (format == "mm:hh:ss") {
-      vModeValue.value = `${mm2}:${hh2}:${ss2}`;
-    } else if (format == "hh:mm") {
-      vModeValue.value = `${hh2}:${mm2}`;
-    } else if (format == "mm:ss") {
-      vModeValue.value = `${mm2}:${ss2}`;
-    }
-  };
-  const clearAll = (e) => {
-    e.stopPropagation();
-    showPopup.value = false;
-    if (minTime != "00:00:00") {
-      const minTimeArr = minTime.split(":");
-      hh.value = minTimeArr[0];
-      mm.value = minTimeArr[1];
-      ss.value = minTimeArr[2];
-    } else {
-      hh.value = "00";
-      mm.value = "00";
-      ss.value = "00";
-    }
-    firsthandActiveTime.value = `${hh.value}:${mm.value}:${ss.value}`;
-    setInputValue(hh.value, mm.value, ss.value);
-  };
-  const isOutOpen = () => {
-    if (autoOpen) {
-      const timeArr = vModeValue.value.split(":");
-      hh.value = timeArr[0];
-      mm.value = timeArr[1];
-      ss.value = timeArr[2];
-      firsthandActiveTime.value = vModeValue.value;
-      setInputValue(hh.value, mm.value, ss.value);
-      isActive.value = true;
-      showPopup.value = autoOpen;
-    }
-  };
-  const chooseTime = (slotTime) => {
-    if (slotTime.type) {
-      if (slotTime.type.toLowerCase() == "hh") {
-        hh.value = slotTime.time;
-      } else if (slotTime.type.toLowerCase() == "mm") {
-        mm.value = slotTime.time;
-      } else if (slotTime.type.toLowerCase() == "ss") {
-        ss.value = slotTime.time;
-      }
-      firsthandActiveTime.value = `${hh.value}:${mm.value}:${ss.value}`;
-      setInputValue(hh.value, mm.value, ss.value);
-    } else {
-      const timeArr = slotTime.time.split(":");
-      hh.value = timeArr[0];
-      mm.value = timeArr[1];
-      ss.value = timeArr[2];
-      firsthandActiveTime.value = `${hh.value}:${mm.value}:${ss.value}`;
-      setInputValue(hh.value, mm.value, ss.value);
-    }
-  };
-  return {
-    isActive,
-    showPopup,
-    devuiTimePicker,
-    timePickerValue,
-    inputDom,
-    timePopupDom,
-    left,
-    top,
-    showClearIcon,
-    firsthandActiveTime,
-    vModeValue,
-    getPopupPosition,
-    getTimeValue,
-    clickVerifyFun,
-    isOutOpen,
-    vModelIsBeyond,
-    clearAll,
-    chooseTime
-  };
-}
-const usePopupLine = (hourListRef, minuteListRef, secondListRef, minTime, maxTime, format, timeListDom) => {
-  const activeTime = ref("00:00:00");
-  const activeHour = ref("00");
-  const activeMinute = ref("00");
-  const activeSecond = ref("00");
-  const activeTimeFun = (e, item, index2) => {
-    if (item.isDisabled) {
-      return false;
-    } else {
-      setTimeActive(item, index2);
-      e.target.parentElement.parentElement.scrollTop = index2 * 32;
-    }
-  };
-  const setTimeActive = (item, index2) => {
-    let activeTimeList = [];
-    let acitveTimeValue = ref("");
-    if (item.flag == "hour") {
-      activeTimeList = hourListRef;
-      acitveTimeValue = activeHour;
-      getItemAstrict(item);
-    } else if (item.flag == "minute") {
-      activeTimeList = minuteListRef;
-      acitveTimeValue = activeMinute;
-      getItemAstrict(item);
-    } else if (item.flag == "second") {
-      activeTimeList = secondListRef;
-      acitveTimeValue = activeSecond;
-    }
-    activeTimeList.map((tiemItem, tiemeIndex) => {
-      tiemItem.isActive = index2 === tiemeIndex;
-    });
-    acitveTimeValue.value = activeTimeList[index2].time;
-    activeTime.value = `${activeHour.value}:${activeMinute.value}:${activeSecond.value}`;
-    if (activeTime.value < minTime) {
-      activeTime.value = minTime;
-      resetTimeValue(minTime);
-    } else if (format == "mm:ss" && `${activeMinute.value}:${activeSecond.value}` > maxTime.slice(3)) {
-      const newMinTime = minTime.slice(0, 3) + maxTime.slice(3);
-      resetTimeValue(newMinTime);
-    } else if (activeTime.value > maxTime) {
-      activeTime.value = maxTime;
-      resetTimeValue(maxTime);
-    }
-  };
-  const getItemAstrict = (item) => {
-    let min = "00";
-    let max = "00";
-    const minTimeHour = minTime.split(":")[0];
-    const minTimeMinute = minTime.split(":")[1];
-    const minTimeSecond = minTime.split(":")[2];
-    const maxTimeHour = maxTime.split(":")[0];
-    const maxTimeMinute = maxTime.split(":")[1];
-    const maxTimeSecond = maxTime.split(":")[2];
-    if (item.flag == "hour") {
-      if (item.time == minTimeHour) {
-        min = minTimeMinute;
-        setItemAstrict(minuteListRef, min, max);
-        activeMinute.value < minTimeMinute && setItemAstrict(secondListRef, minTimeSecond, max);
-      } else if (item.time == maxTimeHour) {
-        max = maxTimeMinute;
-        setItemAstrict(minuteListRef, min, max);
-        setItemAstrict(secondListRef, min, maxTimeSecond);
-      } else {
-        setItemAstrict(minuteListRef, min, max);
-        setItemAstrict(secondListRef, min, max);
-      }
-    }
-    if (item.flag == "minute" && format == "mm:ss") {
-      if (item.time == minTimeMinute) {
-        min = minTimeSecond;
-        setItemAstrict(secondListRef, min, max);
-      } else if (item.time == maxTimeMinute) {
-        max = maxTimeSecond;
-        setItemAstrict(secondListRef, min, max);
-      } else {
-        setItemAstrict(secondListRef, min, max);
-      }
-    } else if (item.flag == "minute") {
-      if (activeHour.value == minTimeHour && item.time == minTimeMinute) {
-        min = minTimeSecond;
-        setItemAstrict(secondListRef, min, max);
-      } else if (activeHour.value == maxTimeHour && item.time == maxTimeMinute) {
-        max = maxTimeSecond;
-        setItemAstrict(secondListRef, min, max);
-      } else {
-        setItemAstrict(secondListRef, min, max);
-      }
-    }
-  };
-  const setItemAstrict = (timeArr, min, max) => {
-    timeArr.map((itme) => {
-      if (min != "00" && itme.time < min) {
-        itme.isDisabled = true;
-      } else if (max != "00" && itme.time > max) {
-        itme.isDisabled = true;
-      } else {
-        itme.isDisabled = false;
-      }
-    });
-  };
-  const resetTimeValue = (time) => {
-    const timeValueArr = time.split(":");
-    const minTiveArr = minTime.split(":");
-    let hh = 0;
-    let mm = 0;
-    let ss = 0;
-    if (format == "hh:mm:ss") {
-      hh = parseInt(timeValueArr[0]);
-      mm = parseInt(timeValueArr[1]);
-      ss = parseInt(timeValueArr[2]);
-      timeListDom.value.children[0].lastElementChild.children[0].scrollTop = hh * 32;
-      timeListDom.value.children[1].lastElementChild.children[0].scrollTop = mm * 32;
-      timeListDom.value.children[2].lastElementChild.children[0].scrollTop = ss * 32;
-      activeHour.value = timeValueArr[0];
-      activeMinute.value = timeValueArr[1];
-      activeSecond.value = timeValueArr[2];
-      resetTimeActive(hourListRef, timeValueArr[0]);
-      resetTimeActive(minuteListRef, timeValueArr[1]);
-      resetTimeActive(secondListRef, timeValueArr[2]);
-      resetTimeAstrict(hourListRef, activeHour.value);
-      resetTimeAstrict(minuteListRef, activeMinute.value);
-    } else if (format == "mm:hh:ss") {
-      hh = parseInt(timeValueArr[0]);
-      mm = parseInt(timeValueArr[1]);
-      ss = parseInt(timeValueArr[2]);
-      timeListDom.value.children[0].lastElementChild.children[0].scrollTop = mm * 32;
-      timeListDom.value.children[1].lastElementChild.children[0].scrollTop = hh * 32;
-      timeListDom.value.children[2].lastElementChild.children[0].scrollTop = ss * 32;
-      activeHour.value = timeValueArr[0];
-      activeMinute.value = timeValueArr[1];
-      activeSecond.value = timeValueArr[2];
-      resetTimeActive(hourListRef, timeValueArr[0]);
-      resetTimeActive(minuteListRef, timeValueArr[1]);
-      resetTimeActive(secondListRef, timeValueArr[2]);
-      resetTimeAstrict(hourListRef, activeHour.value);
-      resetTimeAstrict(minuteListRef, activeMinute.value);
-    } else if (format == "hh:mm") {
-      hh = parseInt(timeValueArr[0]);
-      mm = parseInt(timeValueArr[1]);
-      timeListDom.value.children[0].lastElementChild.children[0].scrollTop = hh * 32;
-      timeListDom.value.children[1].lastElementChild.children[0].scrollTop = mm * 32;
-      activeHour.value = timeValueArr[0];
-      activeMinute.value = timeValueArr[1];
-      resetTimeActive(hourListRef, timeValueArr[0]);
-      resetTimeActive(minuteListRef, timeValueArr[1]);
-      resetTimeAstrict(hourListRef, activeHour.value);
-    } else if (format == "mm:ss") {
-      mm = parseInt(timeValueArr[1]);
-      ss = parseInt(timeValueArr[2]);
-      timeListDom.value.children[0].lastElementChild.children[0].scrollTop = mm * 32;
-      timeListDom.value.children[1].lastElementChild.children[0].scrollTop = ss * 32;
-      activeHour.value = minTiveArr[0];
-      activeMinute.value = timeValueArr[1];
-      activeSecond.value = timeValueArr[2];
-      resetTimeActive(minuteListRef, timeValueArr[1]);
-      resetTimeActive(secondListRef, timeValueArr[2]);
-      resetTimeAstrict(minuteListRef, activeMinute.value);
-    }
-  };
-  const resetTimeAstrict = (timeArr, time) => {
-    timeArr.map((item) => {
-      if (item.time == time) {
-        getItemAstrict(item);
-      }
-    });
-  };
-  const resetTimeActive = (timeArr, itemValue) => {
-    timeArr.map((item) => {
-      item.isActive = item.time === itemValue;
-    });
-  };
-  const getNewTime = () => {
-    return { activeTime, activeHour, activeMinute, activeSecond };
-  };
-  const resetScrollTop = () => {
-    for (let i = 0; i < timeListDom.value.children.length; i++) {
-      timeListDom.value.children[i].lastElementChild.children[0].scrollTop = 0;
-    }
-  };
-  return {
-    activeTime,
-    activeHour,
-    activeMinute,
-    activeSecond,
-    activeTimeFun,
-    resetTimeValue,
-    getNewTime,
-    resetScrollTop
-  };
-};
-function useTimeScroll() {
-  const scrollBoxDom = ref();
-  const scrollContentDom = ref();
-  const scrollThumbDom = ref();
-  const scrollTrackDom = ref();
-  const isDown = ref(false);
-  const getScrollHeight = () => {
-    const thumbHeight = scrollContentDom.value.clientHeight / scrollContentDom.value.scrollHeight * 100;
-    scrollThumbDom.value.style.height = thumbHeight + "%";
-  };
-  const setVirtualScroll = () => {
-    const thumbMoveY = scrollContentDom.value.scrollTop * 100 / scrollContentDom.value.clientHeight;
-    scrollThumbDom.value.style.transform = `translateY(${thumbMoveY}%)`;
-  };
-  const clickTrackFun = (e) => {
-    const offsetNum = scrollTrackDom.value.getBoundingClientRect().top - e.clientY;
-    const offset = Math.abs(offsetNum > 0 ? 0 : offsetNum);
-    const thumbCenter = scrollThumbDom.value.offsetHeight / 2;
-    const thumbPosition = (offset - thumbCenter) * 100 / scrollContentDom.value.offsetHeight;
-    scrollContentDom.value.scrollTop = thumbPosition * scrollContentDom.value.scrollHeight / 100;
-    scrollContentDom.value.style.top = scrollContentDom.value.scrollTop + "px";
-  };
-  const mouseDownThum = () => {
-    isDown.value = true;
-    scrollTrackDom.value.style.opacity = 1;
-  };
-  const mouseOutThum = (e) => {
-    isDown.value = false;
-    thumbMouseMove(e);
-  };
-  const thumbMouseMove = (e) => {
-    const path = e.composedPath && e.composedPath() || e.path;
-    if (path.includes(scrollBoxDom.value) || isDown.value) {
-      scrollTrackDom.value.style.opacity = 1;
-    } else {
-      scrollTrackDom.value.style.opacity = 0;
-    }
-    if (!isDown.value)
-      return;
-    clickTrackFun(e);
-  };
-  const getScrollWidth = () => {
-    const ua = navigator.userAgent;
-    let marginRight = -20;
-    if (ua.indexOf("Chrome") > -1) {
-      marginRight = -8;
-    } else {
-      const outer = document.createElement("div");
-      outer.className = "devui-scrollbar-wrap";
-      outer.style.width = "100px";
-      outer.style.visibility = "hidden";
-      outer.style.position = "absolute";
-      outer.style.top = "-9999px";
-      document.body.appendChild(outer);
-      const widthNoScroll = outer.offsetWidth;
-      outer.style.overflow = "scroll";
-      const inner = document.createElement("div");
-      inner.style.width = "100%";
-      outer.appendChild(inner);
-      const widthWithScroll = inner.offsetWidth;
-      outer.parentNode.removeChild(outer);
-      marginRight = (widthNoScroll - widthWithScroll + 3) * -1;
-    }
-    return marginRight;
-  };
-  return {
-    scrollThumbDom,
-    scrollTrackDom,
-    scrollContentDom,
-    scrollBoxDom,
-    isDown,
-    getScrollHeight,
-    setVirtualScroll,
-    clickTrackFun,
-    mouseDownThum,
-    mouseOutThum,
-    thumbMouseMove,
-    getScrollWidth
-  };
-}
-var index$3 = "";
-var TimeScroll = defineComponent({
-  name: "DTimeScroll",
-  props: timePickerProps,
-  setup(props, ctx) {
-    const {
-      scrollBoxDom,
-      scrollThumbDom,
-      scrollTrackDom,
-      scrollContentDom,
-      isDown,
-      getScrollHeight,
-      setVirtualScroll,
-      clickTrackFun,
-      mouseDownThum,
-      mouseOutThum,
-      thumbMouseMove,
-      getScrollWidth
-    } = useTimeScroll();
-    const marginRight = getScrollWidth();
-    onMounted(() => {
-      getScrollWidth();
-      getScrollHeight();
-      scrollBoxDom.value.addEventListener("click", setVirtualScroll);
-      scrollContentDom.value.addEventListener("scroll", setVirtualScroll);
-      scrollThumbDom.value.addEventListener("mousedown", mouseDownThum);
-      document.addEventListener("mouseup", mouseOutThum);
-      document.addEventListener("mousemove", thumbMouseMove);
-    });
-    onBeforeUnmount(() => {
-      scrollBoxDom.value.removeEventListener("click", setVirtualScroll);
-      scrollContentDom.value.removeEventListener("scroll", setVirtualScroll);
-      scrollThumbDom.value.removeEventListener("mousedown", mouseDownThum);
-    });
-    onUnmounted(() => {
-      document.removeEventListener("mouseup", mouseOutThum);
-      document.removeEventListener("mousemove", thumbMouseMove);
-    });
-    return () => {
-      var _a, _b;
-      return createVNode(Fragment, null, [createVNode("div", {
-        "ref": scrollBoxDom,
-        "class": "devui-scroll-box"
-      }, [createVNode("div", {
-        "ref": scrollContentDom,
-        "class": `box-content ${isDown.value || !props.showAnimation ? "box-content-behavior-auto" : ""}`,
-        "style": {
-          "margin-right": marginRight + "px"
-        }
-      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]), createVNode("div", {
-        "ref": scrollTrackDom,
-        "class": "box-sroll",
-        "onClick": clickTrackFun
-      }, [createVNode("div", {
-        "ref": scrollThumbDom,
-        "class": "scroll-child"
-      }, null)])])]);
-    };
-  }
-});
-var index$2 = "";
-var TimeList = defineComponent({
-  name: "DTimeList",
-  components: {
-    TimeScroll
-  },
-  props: {
-    hourList: {
-      type: Array,
-      default: () => []
-    },
-    minuteList: {
-      type: Array,
-      default: () => []
-    },
-    secondList: {
-      type: Array,
-      default: () => []
-    },
-    format: {
-      type: String,
-      default: "hh:mm:ss"
-    },
-    minTime: {
-      type: String,
-      default: "00:00:00"
-    },
-    maxTime: {
-      type: String,
-      default: "23:59:59"
-    }
-  },
-  setup(props, ctx) {
-    const timeListDom = ref();
-    const {
-      getNewTime,
-      activeTimeFun,
-      resetTimeValue,
-      resetScrollTop
-    } = usePopupLine(props.hourList, props.minuteList, props.secondList, props.minTime, props.maxTime, props.format, timeListDom);
-    const setOutoTime = (time) => {
-      resetTimeValue(time);
-    };
-    const TimeLi = (timeArr) => {
-      return timeArr.map((item, index2) => {
-        return createVNode("li", {
-          "class": `time-li ${item.flag}Id-${index2} ${item.isActive ? "active-li" : ""} ${item.isDisabled ? "disabled-li" : ""}`,
-          "onClick": (e) => {
-            activeTimeFun(e, item, index2);
-          }
-        }, [createVNode("span", null, [item.time])]);
-      });
-    };
-    const TimeUl = (timeList) => {
-      return createVNode("div", {
-        "class": "time-item",
-        "style": {
-          "flex": 1
-        }
-      }, [createVNode(TimeScroll, null, {
-        default: () => [createVNode("ul", {
-          "class": "time-ul"
-        }, [TimeLi(timeList)])]
-      })]);
-    };
-    const formatTimeUl = () => {
-      const timeList = {
-        "hh": props.hourList,
-        "mm": props.minuteList,
-        "ss": props.secondList
-      };
-      const timeFormatArr = props.format.split(":");
-      return timeFormatArr.map((timeItme) => {
-        return TimeUl(timeList[timeItme]);
-      });
-    };
-    ctx.expose({
-      resetScrollTop,
-      setOutoTime,
-      getNewTime
-    });
-    return () => {
-      return createVNode("div", {
-        "class": "devui-time-list",
-        "ref": timeListDom
-      }, [formatTimeUl()]);
-    };
-  }
-});
-class View {
-  constructor() {
-    __publicField(this, "top", "50%");
-    __publicField(this, "left", "50%");
-  }
-}
-const componentProps = {
-  message: String,
-  backdrop: Boolean,
-  view: {
-    type: Object,
-    default: () => new View()
-  },
-  zIndex: Number,
-  isFull: {
-    type: Boolean,
-    default: false
-  }
-};
-class LoadingProps {
-  constructor() {
-    __publicField(this, "target");
-    __publicField(this, "message");
-    __publicField(this, "loadingTemplateRef");
-    __publicField(this, "backdrop", true);
-    __publicField(this, "positionType", "relative");
-    __publicField(this, "view", new View());
-    __publicField(this, "zIndex");
-  }
-}
-var loading = "";
-var Loading = defineComponent({
-  name: "DLoading",
-  inheritAttrs: false,
-  props: componentProps,
-  setup(props) {
-    const style = {
-      top: props.view.top,
-      left: props.view.left,
-      zIndex: props.zIndex
-    };
-    if (!props.message) {
-      style.background = "none";
-    }
-    const isShow = ref(false);
-    const open = () => {
-      isShow.value = true;
-    };
-    const close = () => {
-      isShow.value = false;
-    };
-    return {
-      style,
-      isShow,
-      open,
-      close
-    };
-  },
-  render() {
-    var _a;
-    const {
-      isShow,
-      isFull,
-      backdrop,
-      style,
-      message,
-      $slots
-    } = this;
-    return isShow && createVNode("div", {
-      "class": ["devui-loading-contanier", isFull ? "devui-loading--full" : ""]
-    }, [((_a = $slots.default) == null ? void 0 : _a.call($slots)) || createVNode("div", {
-      "class": "devui-loading-wrapper"
-    }, [backdrop ? createVNode("div", {
-      "class": "devui-loading-mask"
-    }, null) : null, createVNode("div", {
-      "style": style,
-      "class": "devui-loading-area"
-    }, [createVNode("div", {
-      "class": "devui-busy-default-spinner"
-    }, [createVNode("div", {
-      "class": "devui-loading-bar1"
-    }, null), createVNode("div", {
-      "class": "devui-loading-bar2"
-    }, null), createVNode("div", {
-      "class": "devui-loading-bar3"
-    }, null), createVNode("div", {
-      "class": "devui-loading-bar4"
-    }, null)]), message ? createVNode("span", {
-      "class": "devui-loading-text"
-    }, [message]) : null])])]);
-  }
-});
-const COMPONENT_CONTAINER_SYMBOL = Symbol("dev_component_container");
-function createComponent(Component, props, children = null) {
-  const vnode = h(Component, __spreadValues({}, props), children);
-  const container = document.createElement("div");
-  vnode[COMPONENT_CONTAINER_SYMBOL] = container;
-  render(vnode, container);
-  return vnode.component;
-}
-function unmountComponent(ComponnetInstance) {
-  render(null, ComponnetInstance == null ? void 0 : ComponnetInstance.vnode[COMPONENT_CONTAINER_SYMBOL]);
-}
-const loadingConstructor = defineComponent(Loading);
-const cacheInstance = /* @__PURE__ */ new WeakSet();
-const isEmpty = (val) => {
-  if (!val)
-    return true;
-  if (Array.isArray(val))
-    return val.length === 0;
-  if (val instanceof Set || val instanceof Map)
-    return val.size === 0;
-  if (val instanceof Promise)
-    return false;
-  if (typeof val === "object") {
-    try {
-      return Object.keys(val).length === 0;
-    } catch (e) {
-      return false;
-    }
-  }
-  return false;
-};
-const getType = (vari) => {
-  return Object.prototype.toString.call(vari).slice(8, -1).toLowerCase();
-};
-const isPromise = (value) => {
-  const type = getType(value);
-  switch (type) {
-    case "promise":
-      return [value];
-    case "array":
-      if (value.some((val) => getType(val) !== "promise")) {
-        console.error(new TypeError("Binding values should all be of type Promise"));
-        return "error";
-      }
-      return value;
-    default:
-      return false;
-  }
-};
-const unmount = (el) => {
-  cacheInstance.delete(el);
-  el.instance.proxy.close();
-  unmountComponent(el.instance);
-};
-const toggleLoading = (el, binding) => {
-  if (binding.value) {
-    const vals = isPromise(binding.value);
-    if (vals === "error")
-      return;
-    el.instance.proxy.open();
-    el.appendChild(el.mask);
-    cacheInstance.add(el);
-    if (vals) {
-      Promise.all(vals).catch((err) => {
-        console.error(new Error("Promise handling errors"), err);
-      }).finally(() => {
-        unmount(el);
-      });
-    }
-  } else {
-    unmount(el);
-  }
-};
-const removeAttribute = (el) => {
-  el.removeAttribute("zindex");
-  el.removeAttribute("positiontype");
-  el.removeAttribute("backdrop");
-  el.removeAttribute("message");
-  el.removeAttribute("view");
-  el.removeAttribute("loadingtemplateref");
-};
-const handleProps = (el, vprops) => {
-  const props = __spreadValues(__spreadValues({}, new LoadingProps()), vprops);
-  const loadingTemplateRef = props.loadingTemplateRef;
-  const loadingInstance = createComponent(loadingConstructor, __spreadValues({}, props), loadingTemplateRef ? () => loadingTemplateRef : null);
-  el.style.position = props.positionType;
-  el.options = props;
-  el.instance = loadingInstance;
-  el.mask = loadingInstance.proxy.$el;
-};
-const loadingDirective = {
-  mounted: function(el, binding, vnode) {
-    handleProps(el, vnode.props);
-    removeAttribute(el);
-    !isEmpty(binding.value) && toggleLoading(el, binding);
-  },
-  updated: function(el, binding, vnode) {
-    if (!isEmpty(binding.value) && cacheInstance.has(el) || isEmpty(binding.value) && !cacheInstance.has(el))
-      return;
-    !cacheInstance.has(el) && handleProps(el, vnode.props);
-    removeAttribute(el);
-    toggleLoading(el, binding);
-  }
-};
-const buttonProps = {
-  variant: {
-    type: String,
-    default: "outline"
-  },
-  size: {
-    type: String,
-    default: "md"
-  },
-  color: {
-    type: String
-  },
-  icon: {
-    type: String,
-    default: ""
-  },
-  loading: {
-    type: Boolean,
-    default: false
-  },
-  disabled: {
-    type: Boolean,
-    default: false
-  }
-};
-function useButton(props, ctx) {
-  const hasContent = computed(() => ctx.slots.default);
-  const colorMap = {
-    solid: "primary",
-    outline: "secondary",
-    text: "secondary"
-  };
-  const defaultColor = colorMap[props.variant];
-  const classes = computed(() => ({
-    "devui-btn": true,
-    [`devui-btn-${props.variant}`]: true,
-    [`devui-btn-${props.variant}-${props.color || defaultColor}`]: true,
-    [`devui-btn-${props.size}`]: true,
-    "devui-btn-icon-wrap": props.icon,
-    "devui-btn-icon": props.icon && !hasContent.value && props.variant !== "solid"
-  }));
-  const iconClass = computed(() => {
-    if (!props.icon) {
-      return;
-    }
-    const origin = "devui-icon-fix icon";
-    if (hasContent.value) {
-      return `${origin} clear-right-5`;
-    } else {
-      return origin;
-    }
-  });
-  return { classes, iconClass };
-}
-var button = "";
-var Button = defineComponent({
-  name: "DButton",
-  directives: {
-    devLoading: loadingDirective
-  },
-  props: buttonProps,
-  emits: ["click"],
-  setup(props, ctx) {
-    const {
-      icon,
-      disabled,
-      loading: loading2
-    } = toRefs(props);
-    const {
-      classes,
-      iconClass
-    } = useButton(props, ctx);
-    const onClick = (e) => {
-      if (loading2.value) {
-        return;
-      }
-      ctx.emit("click", e);
-    };
-    return () => {
-      var _a, _b;
-      return withDirectives(createVNode("button", {
-        "class": classes.value,
-        "disabled": disabled.value,
-        "onClick": onClick
-      }, [icon.value && createVNode(Icon, {
-        "name": icon.value,
-        "size": "12px",
-        "class": iconClass.value
-      }, null), createVNode("span", {
-        "class": "button-content"
-      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)])]), [[resolveDirective("dLoading"), loading2.value]]);
-    };
-  }
-});
-var index$1 = "";
-var TimePopup = defineComponent({
-  name: "DTimePopup",
-  components: {
-    TimeList,
-    Button
-  },
-  props: {
-    showPopup: {
-      type: Boolean,
-      default: false
-    },
-    popupTop: {
-      type: Number,
-      default: -100
-    },
-    popupLeft: {
-      type: Number,
-      default: -100
-    },
-    popupWidth: {
-      type: Number,
-      default: 300
-    },
-    popupFormat: {
-      type: String,
-      default: "hh:mm:ss"
-    },
-    minTime: {
-      type: String,
-      default: "00:00:00"
-    },
-    maxTime: {
-      type: String,
-      default: "23:59:59"
-    },
-    bindData: {
-      type: String,
-      default: "00:00:00"
-    }
-  },
-  emits: ["subData"],
-  setup(props, ctx) {
-    const popupDome = ref();
-    const timeListDom = ref();
-    const hourList = initializeTimeData("hour");
-    const minuteList = initializeTimeData("minute");
-    const secondList = initializeTimeData("second");
-    onMounted(() => {
-      setTimeAstrict(hourList, minuteList, secondList, props.minTime, props.maxTime, props.popupFormat);
-    });
-    watch(() => [props.showPopup, props.bindData], ([showPopup, newTimeVal], [oldShowPopup, oldTimeVal]) => {
-      if (showPopup || newTimeVal != oldTimeVal) {
-        timeListDom.value.setOutoTime(newTimeVal);
-      } else {
-        timeListDom.value.resetScrollTop();
-      }
-    });
-    const changTimeData = () => {
-      return timeListDom.value.getNewTime();
-    };
-    const subDataFun = (e) => {
-      e.stopPropagation();
-      ctx.emit("subData");
-    };
-    ctx.expose({
-      changTimeData
-    });
-    return () => {
-      var _a, _b;
-      return createVNode(Fragment, null, [createVNode("div", {
-        "ref": popupDome,
-        "class": `devui-time-popup ${props.showPopup ? "devui-show-time-popup" : ""}`,
-        "style": {
-          "width": props.popupWidth + "px",
-          "top": props.popupTop + "px",
-          "left": props.popupLeft + "px"
-        }
-      }, [createVNode(TimeList, {
-        "ref": timeListDom,
-        "hourList": hourList,
-        "minuteList": minuteList,
-        "secondList": secondList,
-        "minTime": props.minTime,
-        "maxTime": props.maxTime,
-        "format": props.popupFormat
-      }, null), createVNode("div", {
-        "class": "devui-time-popup-btn"
-      }, [createVNode("div", {
-        "class": "popup-slots"
-      }, [(_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]), createVNode("div", {
-        "onClick": subDataFun
-      }, [createVNode(Button, {
-        "variant": "common"
-      }, {
-        default: () => [createTextVNode("\u786E\u5B9A")]
-      })])])])]);
-    };
-  }
-});
-var timePicker = "";
-var TimePicker = defineComponent({
-  name: "DTimePicker",
-  components: {
-    TimePopup
-  },
-  props: timePickerProps,
-  emits: ["selectedTimeChage", "update:modelValue"],
-  setup(props, ctx) {
-    const activeHour = ref("00");
-    const activeMinute = ref("00");
-    const activeSecond = ref("00");
-    const format = props.format.toLowerCase();
-    const {
-      isActive,
-      showPopup,
-      devuiTimePicker,
-      inputDom,
-      left,
-      top,
-      showClearIcon,
-      firsthandActiveTime,
-      chooseTime,
-      getTimeValue,
-      clickVerifyFun,
-      isOutOpen,
-      vModelIsBeyond,
-      clearAll,
-      timePopupDom,
-      vModeValue,
-      getPopupPosition
-    } = useTimePicker(activeHour, activeMinute, activeSecond, props.minTime, props.maxTime, format, props.autoOpen, props.disabled, props.modelValue);
-    const selectedTimeChage = (e) => {
-      isActive.value = false;
-      showPopup.value = false;
-      ctx.emit("selectedTimeChage", vModeValue.value);
-    };
-    onMounted(() => {
-      getPopupPosition();
-      isOutOpen();
-      vModelIsBeyond();
-      document.addEventListener("click", clickVerifyFun);
-      document.addEventListener("click", getTimeValue);
-      document.addEventListener("scroll", getPopupPosition);
-      window.addEventListener("resize", getPopupPosition);
-    });
-    onUnmounted(() => {
-      document.removeEventListener("click", clickVerifyFun);
-      document.removeEventListener("click", getTimeValue);
-      document.removeEventListener("scroll", getPopupPosition);
-      window.removeEventListener("resize", getPopupPosition);
-    });
-    watch(vModeValue, (newValue) => {
-      ctx.emit("update:modelValue", vModeValue.value);
-      if (newValue != props.minTime && newValue != "00:00") {
-        showClearIcon.value = true;
-      } else {
-        showClearIcon.value = false;
-      }
-    });
-    ctx.expose({
-      clearAll,
-      chooseTime
-    });
-    return () => {
-      return createVNode(Fragment, null, [createVNode("div", {
-        "class": `devui-time-picker ${isActive.value ? "time-picker-active" : ""} ${props.disabled ? "picker-disabled" : ""}`,
-        "ref": devuiTimePicker
-      }, [createVNode(TimePopup, {
-        "ref": timePopupDom,
-        "showPopup": showPopup.value,
-        "popupTop": top.value,
-        "popupLeft": left.value,
-        "popupWidth": props.timePickerWidth,
-        "popupFormat": props.format.toLowerCase(),
-        "minTime": props.minTime,
-        "maxTime": props.maxTime,
-        "bindData": firsthandActiveTime.value,
-        "onSubData": selectedTimeChage
-      }, {
-        default: () => {
-          var _a, _b;
-          return [(_b = (_a = ctx.slots).customViewTemplate) == null ? void 0 : _b.call(_a)];
-        }
-      }), createVNode("input", {
-        "ref": inputDom,
-        "type": "text",
-        "value": vModeValue.value,
-        "placeholder": `${props.placeholder}`,
-        "disabled": props.disabled,
-        "class": "time-input"
-      }, null), createVNode("div", {
-        "class": "time-input-icon"
-      }, [createVNode("div", {
-        "onClick": clearAll
-      }, [showClearIcon.value ? createVNode(Icon, {
-        "size": "small",
-        "name": "close"
-      }, null) : ""]), createVNode("div", null, [createVNode(Icon, {
-        "size": "small",
-        "name": "time"
-      }, null)])])])]);
-    };
-  }
-});
-TimePicker.install = function(app) {
-  app.component(TimePicker.name, TimePicker);
-};
-var index = {
-  title: "TimePicker \u65F6\u95F4\u9009\u62E9\u5668",
-  category: "\u6570\u636E\u5F55\u5165",
-  status: "90%",
-  install(app) {
-    app.use(TimePicker);
-  }
-};
-export { TimePicker, index as default };