element-plus
Version:
A Component Library for Vue 3
227 lines (224 loc) • 8.46 kB
JavaScript
import { defineComponent, ref, computed, inject, resolveComponent, openBlock, createBlock, Transition, withCtx, createElementBlock, normalizeClass, createElementVNode, createVNode, toDisplayString, createCommentVNode } from 'vue';
import dayjs from 'dayjs';
import '../../../../constants/index.mjs';
import '../../../../hooks/index.mjs';
import '../../../../utils/index.mjs';
import TimeSpinner from './basic-time-spinner.mjs';
import { useOldValue, getAvailableArrs } from './useTimePicker.mjs';
import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.mjs';
import { useNamespace } from '../../../../hooks/use-namespace/index.mjs';
import { useLocale } from '../../../../hooks/use-locale/index.mjs';
import { isUndefined } from '../../../../utils/types.mjs';
import { EVENT_CODE } from '../../../../constants/aria.mjs';
const _sfc_main = defineComponent({
components: {
TimeSpinner
},
props: {
visible: Boolean,
actualVisible: {
type: Boolean,
default: void 0
},
datetimeRole: {
type: String
},
parsedValue: {
type: [Object, String]
},
format: {
type: String,
default: ""
}
},
emits: ["pick", "select-range", "set-picker-option"],
setup(props, ctx) {
const ns = useNamespace("time");
const { t, lang } = useLocale();
const selectionRange = ref([0, 2]);
const oldValue = useOldValue(props);
const transitionName = computed(() => {
return isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
});
const showSeconds = computed(() => {
return props.format.includes("ss");
});
const amPmMode = computed(() => {
if (props.format.includes("A"))
return "A";
if (props.format.includes("a"))
return "a";
return "";
});
const isValidValue = (_date) => {
const parsedDate = dayjs(_date).locale(lang.value);
const result = getRangeAvailableTime(parsedDate);
return parsedDate.isSame(result);
};
const handleCancel = () => {
ctx.emit("pick", oldValue.value, false);
};
const handleConfirm = (visible = false, first = false) => {
if (first)
return;
ctx.emit("pick", props.parsedValue, visible);
};
const handleChange = (_date) => {
if (!props.visible) {
return;
}
const result = getRangeAvailableTime(_date).millisecond(0);
ctx.emit("pick", result, true);
};
const setSelectionRange = (start, end) => {
ctx.emit("select-range", start, end);
selectionRange.value = [start, end];
};
const changeSelectionRange = (step) => {
const list = [0, 3].concat(showSeconds.value ? [6] : []);
const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
const index = list.indexOf(selectionRange.value[0]);
const next = (index + step + list.length) % list.length;
timePickerOptions["start_emitSelectRange"](mapping[next]);
};
const handleKeydown = (event) => {
const code = event.code;
if (code === EVENT_CODE.left || code === EVENT_CODE.right) {
const step = code === EVENT_CODE.left ? -1 : 1;
changeSelectionRange(step);
event.preventDefault();
return;
}
if (code === EVENT_CODE.up || code === EVENT_CODE.down) {
const step = code === EVENT_CODE.up ? -1 : 1;
timePickerOptions["start_scrollDown"](step);
event.preventDefault();
return;
}
};
const getRangeAvailableTime = (date) => {
const availableMap = {
hour: getAvailableHours,
minute: getAvailableMinutes,
second: getAvailableSeconds
};
let result = date;
["hour", "minute", "second"].forEach((_) => {
if (availableMap[_]) {
let availableArr;
const method = availableMap[_];
if (_ === "minute") {
availableArr = method(result.hour(), props.datetimeRole);
} else if (_ === "second") {
availableArr = method(result.hour(), result.minute(), props.datetimeRole);
} else {
availableArr = method(props.datetimeRole);
}
if (availableArr && availableArr.length && !availableArr.includes(result[_]())) {
result = result[_](availableArr[0]);
}
}
});
return result;
};
const parseUserInput = (value) => {
if (!value)
return null;
return dayjs(value, props.format).locale(lang.value);
};
const formatToString = (value) => {
if (!value)
return null;
return value.format(props.format);
};
const getDefaultValue = () => {
return dayjs(defaultValue).locale(lang.value);
};
ctx.emit("set-picker-option", ["isValidValue", isValidValue]);
ctx.emit("set-picker-option", ["formatToString", formatToString]);
ctx.emit("set-picker-option", ["parseUserInput", parseUserInput]);
ctx.emit("set-picker-option", ["handleKeydown", handleKeydown]);
ctx.emit("set-picker-option", [
"getRangeAvailableTime",
getRangeAvailableTime
]);
ctx.emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
const timePickerOptions = {};
const onSetOption = (e) => {
timePickerOptions[e[0]] = e[1];
};
const pickerBase = inject("EP_PICKER_BASE");
const {
arrowControl,
disabledHours,
disabledMinutes,
disabledSeconds,
defaultValue
} = pickerBase.props;
const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = getAvailableArrs(disabledHours, disabledMinutes, disabledSeconds);
return {
ns,
transitionName,
arrowControl,
onSetOption,
t,
handleConfirm,
handleChange,
setSelectionRange,
amPmMode,
showSeconds,
handleCancel,
disabledHours,
disabledMinutes,
disabledSeconds
};
}
});
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
const _component_time_spinner = resolveComponent("time-spinner");
return openBlock(), createBlock(Transition, { name: _ctx.transitionName }, {
default: withCtx(() => [
_ctx.actualVisible || _ctx.visible ? (openBlock(), createElementBlock("div", {
key: 0,
class: normalizeClass(_ctx.ns.b("panel"))
}, [
createElementVNode("div", {
class: normalizeClass([_ctx.ns.be("panel", "content"), { "has-seconds": _ctx.showSeconds }])
}, [
createVNode(_component_time_spinner, {
ref: "spinner",
role: _ctx.datetimeRole || "start",
"arrow-control": _ctx.arrowControl,
"show-seconds": _ctx.showSeconds,
"am-pm-mode": _ctx.amPmMode,
"spinner-date": _ctx.parsedValue,
"disabled-hours": _ctx.disabledHours,
"disabled-minutes": _ctx.disabledMinutes,
"disabled-seconds": _ctx.disabledSeconds,
onChange: _ctx.handleChange,
onSetOption: _ctx.onSetOption,
onSelectRange: _ctx.setSelectionRange
}, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onChange", "onSetOption", "onSelectRange"])
], 2),
createElementVNode("div", {
class: normalizeClass(_ctx.ns.be("panel", "footer"))
}, [
createElementVNode("button", {
type: "button",
class: normalizeClass([_ctx.ns.be("panel", "btn"), "cancel"]),
onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleCancel && _ctx.handleCancel(...args))
}, toDisplayString(_ctx.t("el.datepicker.cancel")), 3),
createElementVNode("button", {
type: "button",
class: normalizeClass([_ctx.ns.be("panel", "btn"), "confirm"]),
onClick: _cache[1] || (_cache[1] = ($event) => _ctx.handleConfirm())
}, toDisplayString(_ctx.t("el.datepicker.confirm")), 3)
], 2)
], 2)) : createCommentVNode("v-if", true)
]),
_: 1
}, 8, ["name"]);
}
var TimePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/time-picker-com/panel-time-pick.vue"]]);
export { TimePickPanel as default };
//# sourceMappingURL=panel-time-pick.mjs.map