yanzhen-design-vue/lib/components/time/src/time.vue2.cjs

"use strict";
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
const vue = require("vue");
const antDesignVue = require("ant-design-vue");
const dayjs = require("dayjs");
const lodashEs = require("lodash-es");
const time = require("./time.cjs");
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...{ name: time.timeName },
  __name: "time",
  props: time.timeProps,
  emits: time.timeEmits,
  setup(__props, { expose: __expose, emit: __emit }) {
    const { ns } = time.timeOptions;
    const props = __props;
    const emit = __emit;
    const slots = vue.useSlots();
    const slotKeys = Object.keys(slots);
    const formatTimeMap = () => {
      const hour = "hour";
      const minute = "minute";
      const second = "second";
      return {
        [hour]: {
          type: hour,
          format: "YYYY-MM-DD",
          totalNumber: 24
        },
        [minute]: {
          type: minute,
          format: "YYYY-MM-DD HH",
          totalNumber: 60
        },
        [second]: {
          type: second,
          format: "YYYY-MM-DD HH:mm",
          totalNumber: 60
        }
      };
    };
    const format = vue.computed(() => {
      const { showTime, expandFormat } = props;
      return showTime ? `${expandFormat || "YYYY-MM-DD"} HH:mm:ss` : `${expandFormat || "YYYY-MM-DD"}`;
    });
    const dateValue = vue.computed(() => {
      if (props.value) {
        if (props.isTimeStamp) {
          return dayjs(+props.value);
        } else {
          const formatTime = setFormatValue(String(props.value));
          return dayjs(formatTime);
        }
      } else {
        return null;
      }
    });
    const setFormatValue = (value) => {
      let formatValue = lodashEs.cloneDeep(value);
      if (!formatValue) return value;
      const { showTime } = props;
      const hasSpace = formatValue.includes(" ");
      if (showTime) {
        if (!hasSpace) formatValue = `${formatValue} 00:00:00`;
      } else {
        if (hasSpace) formatValue = lodashEs.get(formatValue.split(" "), "[0]", "");
      }
      if (formatValue !== value) {
        emit("update:value", formatValue);
        return formatValue;
      } else {
        return value;
      }
    };
    const disabledDate = (current) => {
      const { beginTime: time1, endTime: time2 } = props;
      const beginTime = dayjs(time1).startOf("day").format("YYYY-MM-DD HH:mm:ss");
      const endTime = dayjs(time2).endOf("day").format("YYYY-MM-DD HH:mm:ss");
      if (time1 && !time2) {
        return current < dayjs(beginTime);
      } else if (!time1 && time2) {
        return current > dayjs(endTime);
      } else if (time1 && time2) {
        return current < dayjs(beginTime) || current > dayjs(endTime);
      }
    };
    const getDisabledDateTime = (momentTime, formatInfo) => {
      const { type, format: format2, totalNumber } = formatInfo;
      const formatMap = formatTimeMap();
      const startTime = dayjs(props.beginTime).startOf(type);
      const startVal = startTime.valueOf();
      const endTime = dayjs(props.endTime).startOf(type);
      const endVal = endTime.valueOf();
      const disabledTimes = [];
      const currentTime = dayjs(momentTime).format(format2);
      for (let t = 0; t < totalNumber; t++) {
        const time2 = String(t).padStart(2, "0");
        let fullTimeStr = "";
        switch (formatInfo.type) {
          case formatMap.hour.type: {
            fullTimeStr = `${currentTime} ${time2}:00:00`;
            break;
          }
          case formatMap.minute.type: {
            fullTimeStr = `${currentTime}:${time2}:00`;
            break;
          }
          case formatMap.second.type: {
            fullTimeStr = `${currentTime}:${time2}`;
          }
        }
        const fullValue = new Date(fullTimeStr).getTime();
        if (fullValue < startVal || fullValue > endVal) {
          disabledTimes.push(t);
        }
      }
      return disabledTimes;
    };
    const disabledDateTime = (currentDate) => {
      let hasdisabledTimes = true;
      const formatMap = formatTimeMap();
      const { beginTime, endTime } = props;
      if (!beginTime && !endTime) hasdisabledTimes = false;
      return {
        disabledHours: () => hasdisabledTimes ? getDisabledDateTime(currentDate, formatMap.hour) : [],
        disabledMinutes: () => hasdisabledTimes ? getDisabledDateTime(currentDate, formatMap.minute) : [],
        disabledSeconds: () => hasdisabledTimes ? getDisabledDateTime(currentDate, formatMap.second) : []
      };
    };
    const handleChange = (date, dateString) => {
      const { isTimeStamp } = props;
      const dataValue = isTimeStamp ? new Date(dateString).getTime() : dateString;
      emit("update:value", dataValue);
      emit("change", dataValue);
      emit("blur");
    };
    const handleBlur = (...args) => {
      emit("blur", ...args);
    };
    const _ref = vue.ref();
    __expose({
      ref: _ref
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createBlock(vue.unref(antDesignVue.DatePicker), vue.mergeProps({
        ref_key: "_ref",
        ref: _ref
      }, _ctx.$attrs, {
        class: [vue.unref(ns).b()],
        value: dateValue.value,
        format: format.value,
        "show-time": props.showTime,
        placeholder: props.placeholder,
        "disabled-date": disabledDate,
        "disabled-time": disabledDateTime,
        onChange: handleChange,
        onBlur: handleBlur
      }), vue.createSlots({ _: 2 }, [
        vue.renderList(vue.unref(slotKeys), (slot) => {
          return {
            name: slot,
            fn: vue.withCtx((slotItem) => [
              vue.renderSlot(_ctx.$slots, slot, vue.normalizeProps(vue.guardReactiveProps(slotItem)))
            ])
          };
        })
      ]), 1040, ["class", "value", "format", "show-time", "placeholder"]);
    };
  }
});
exports.default = _sfc_main;