IT-product/it
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

测试

Browse Source
This commit is contained in:
XCool
2025-11-03 17:03:57 +08:00
commit 7a04b85667
16804 changed files with 2492292 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
frontend/node_modules/element-plus/lib/components/time-picker/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,10 @@
import TimePicker from './src/time-picker';
import CommonPicker from './src/common/picker.vue';
import TimePickPanel from './src/time-picker-com/panel-time-pick.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export * from './src/utils';
export * from './src/constants';
export * from './src/common/props';
export declare const ElTimePicker: SFCWithInstall<typeof TimePicker>;
export { CommonPicker, TimePickPanel };
export default ElTimePicker;

39
frontend/node_modules/element-plus/lib/components/time-picker/index.js generated vendored Normal file
View File

@@ -0,0 +1,39 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var timePicker = require('./src/time-picker.js');
var picker = require('./src/common/picker.js');
var panelTimePick = require('./src/time-picker-com/panel-time-pick.js');
var utils = require('./src/utils.js');
var constants = require('./src/constants.js');
var props = require('./src/common/props.js');
var install = require('../../utils/vue/install.js');
const ElTimePicker = install.withInstall(timePicker["default"]);
exports.CommonPicker = picker["default"];
exports.TimePickPanel = panelTimePick["default"];
exports.buildTimeList = utils.buildTimeList;
exports.dateEquals = utils.dateEquals;
exports.dayOrDaysToDate = utils.dayOrDaysToDate;
exports.extractDateFormat = utils.extractDateFormat;
exports.extractTimeFormat = utils.extractTimeFormat;
exports.formatter = utils.formatter;
exports.makeList = utils.makeList;
exports.parseDate = utils.parseDate;
exports.rangeArr = utils.rangeArr;
exports.valueEquals = utils.valueEquals;
exports.DEFAULT_FORMATS_DATE = constants.DEFAULT_FORMATS_DATE;
exports.DEFAULT_FORMATS_DATEPICKER = constants.DEFAULT_FORMATS_DATEPICKER;
exports.DEFAULT_FORMATS_TIME = constants.DEFAULT_FORMATS_TIME;
exports.PICKER_BASE_INJECTION_KEY = constants.PICKER_BASE_INJECTION_KEY;
exports.PICKER_POPPER_OPTIONS_INJECTION_KEY = constants.PICKER_POPPER_OPTIONS_INJECTION_KEY;
exports.ROOT_COMMON_PICKER_INJECTION_KEY = constants.ROOT_COMMON_PICKER_INJECTION_KEY;
exports.timeUnits = constants.timeUnits;
exports.timePickerDefaultProps = props.timePickerDefaultProps;
exports.timePickerRangeTriggerProps = props.timePickerRangeTriggerProps;
exports.timePickerRngeTriggerProps = props.timePickerRngeTriggerProps;
exports.ElTimePicker = ElTimePicker;
exports["default"] = ElTimePicker;
//# sourceMappingURL=index.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.js","sources":["../../../../../packages/components/time-picker/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport TimePicker from './src/time-picker'\nimport CommonPicker from './src/common/picker.vue'\nimport TimePickPanel from './src/time-picker-com/panel-time-pick.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport * from './src/utils'\nexport * from './src/constants'\nexport * from './src/common/props'\n\nexport const ElTimePicker: SFCWithInstall<typeof TimePicker> =\n withInstall(TimePicker)\n\nexport { CommonPicker, TimePickPanel }\nexport default ElTimePicker\n"],"names":["withInstall","TimePicker"],"mappings":";;;;;;;;;;;;AAOY,MAAC,YAAY,GAAGA,mBAAW,CAACC,qBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

131
frontend/node_modules/element-plus/lib/components/time-picker/src/common/picker-range-trigger.js generated vendored Normal file
View File

@@ -0,0 +1,131 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var props = require('./props.js');
var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
var useFormItem = require('../../../form/src/hooks/use-form-item.js');
var index = require('../../../../hooks/use-attrs/index.js');
var index$1 = require('../../../../hooks/use-namespace/index.js');
var index$2 = require('../../../../hooks/use-focus-controller/index.js');
const __default__ = vue.defineComponent({
name: "PickerRangeTrigger",
inheritAttrs: false
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
...__default__,
props: props.timePickerRangeTriggerProps,
emits: [
"mouseenter",
"mouseleave",
"click",
"touchstart",
"focus",
"blur",
"startInput",
"endInput",
"startChange",
"endChange"
],
setup(__props, { expose, emit }) {
const props = __props;
const { formItem } = useFormItem.useFormItem();
const { inputId } = useFormItem.useFormItemInputId(vue.reactive({ id: vue.computed(() => {
var _a;
return (_a = props.id) == null ? void 0 : _a[0];
}) }), {
formItemContext: formItem
});
const attrs = index.useAttrs();
const nsDate = index$1.useNamespace("date");
const nsRange = index$1.useNamespace("range");
const inputRef = vue.ref();
const endInputRef = vue.ref();
const { wrapperRef, isFocused } = index$2.useFocusController(inputRef, {
disabled: vue.computed(() => props.disabled)
});
const handleClick = (evt) => {
emit("click", evt);
};
const handleMouseEnter = (evt) => {
emit("mouseenter", evt);
};
const handleMouseLeave = (evt) => {
emit("mouseleave", evt);
};
const handleTouchStart = (evt) => {
emit("touchstart", evt);
};
const handleStartInput = (evt) => {
emit("startInput", evt);
};
const handleEndInput = (evt) => {
emit("endInput", evt);
};
const handleStartChange = (evt) => {
emit("startChange", evt);
};
const handleEndChange = (evt) => {
emit("endChange", evt);
};
const focus = () => {
var _a;
(_a = inputRef.value) == null ? void 0 : _a.focus();
};
const blur = () => {
var _a, _b;
(_a = inputRef.value) == null ? void 0 : _a.blur();
(_b = endInputRef.value) == null ? void 0 : _b.blur();
};
expose({
focus,
blur
});
return (_ctx, _cache) => {
return vue.openBlock(), vue.createElementBlock("div", {
ref_key: "wrapperRef",
ref: wrapperRef,
class: vue.normalizeClass([vue.unref(nsDate).is("active", vue.unref(isFocused)), _ctx.$attrs.class]),
style: vue.normalizeStyle(_ctx.$attrs.style),
onClick: handleClick,
onMouseenter: handleMouseEnter,
onMouseleave: handleMouseLeave,
onTouchstartPassive: handleTouchStart
}, [
vue.renderSlot(_ctx.$slots, "prefix"),
vue.createElementVNode("input", vue.mergeProps(vue.unref(attrs), {
id: vue.unref(inputId),
ref_key: "inputRef",
ref: inputRef,
name: _ctx.name && _ctx.name[0],
placeholder: _ctx.startPlaceholder,
value: _ctx.modelValue && _ctx.modelValue[0],
class: vue.unref(nsRange).b("input"),
disabled: _ctx.disabled,
onInput: handleStartInput,
onChange: handleStartChange
}), null, 16, ["id", "name", "placeholder", "value", "disabled"]),
vue.renderSlot(_ctx.$slots, "range-separator"),
vue.createElementVNode("input", vue.mergeProps(vue.unref(attrs), {
id: _ctx.id && _ctx.id[1],
ref_key: "endInputRef",
ref: endInputRef,
name: _ctx.name && _ctx.name[1],
placeholder: _ctx.endPlaceholder,
value: _ctx.modelValue && _ctx.modelValue[1],
class: vue.unref(nsRange).b("input"),
disabled: _ctx.disabled,
onInput: handleEndInput,
onChange: handleEndChange
}), null, 16, ["id", "name", "placeholder", "value", "disabled"]),
vue.renderSlot(_ctx.$slots, "suffix")
], 38);
};
}
});
var PickerRangeTrigger = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "picker-range-trigger.vue"]]);
exports["default"] = PickerRangeTrigger;
//# sourceMappingURL=picker-range-trigger.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/common/picker-range-trigger.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

84
frontend/node_modules/element-plus/lib/components/time-picker/src/common/picker-range-trigger.vue.d.ts generated vendored Normal file
View File

@@ -0,0 +1,84 @@
declare function __VLS_template(): {
prefix?(_: {}): any;
"range-separator"?(_: {}): any;
suffix?(_: {}): any;
};
declare const __VLS_component: import("vue").DefineComponent<{
readonly id: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly modelValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string | null, string | null]) | (() => import("./props").UserInput) | ((new (...args: any[]) => string | [string | null, string | null]) | (() => import("./props").UserInput))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly disabled: BooleanConstructor;
}, {
focus: () => void;
blur: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
click: (...args: any[]) => void;
focus: (...args: any[]) => void;
blur: (...args: any[]) => void;
mouseenter: (...args: any[]) => void;
mouseleave: (...args: any[]) => void;
touchstart: (...args: any[]) => void;
startInput: (...args: any[]) => void;
endInput: (...args: any[]) => void;
startChange: (...args: any[]) => void;
endChange: (...args: any[]) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly id: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly modelValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string | null, string | null]) | (() => import("./props").UserInput) | ((new (...args: any[]) => string | [string | null, string | null]) | (() => import("./props").UserInput))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly disabled: BooleanConstructor;
}>> & {
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onClick?: ((...args: any[]) => any) | undefined;
onMouseenter?: ((...args: any[]) => any) | undefined;
onMouseleave?: ((...args: any[]) => any) | undefined;
onTouchstart?: ((...args: any[]) => any) | undefined;
onStartInput?: ((...args: any[]) => any) | undefined;
onEndInput?: ((...args: any[]) => any) | undefined;
onStartChange?: ((...args: any[]) => any) | undefined;
onEndChange?: ((...args: any[]) => any) | undefined;
}, {
readonly disabled: boolean;
}>;
declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
};

593
frontend/node_modules/element-plus/lib/components/time-picker/src/common/picker.js generated vendored Normal file
View File

@@ -0,0 +1,593 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var core = require('@vueuse/core');
var index$4 = require('../../../input/index.js');
var index$5 = require('../../../icon/index.js');
var index$3 = require('../../../tooltip/index.js');
var iconsVue = require('@element-plus/icons-vue');
var utils = require('../utils.js');
var constants = require('../constants.js');
var useCommonPicker = require('../composables/use-common-picker.js');
var props = require('./props.js');
var pickerRangeTrigger = require('./picker-range-trigger.js');
var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
var index$1 = require('../../../../hooks/use-empty-values/index.js');
var event = require('../../../../constants/event.js');
var index = require('../../../../hooks/use-namespace/index.js');
var useFormItem = require('../../../form/src/hooks/use-form-item.js');
var useFormCommonProps = require('../../../form/src/hooks/use-form-common-props.js');
var index$2 = require('../../../../hooks/use-focus-controller/index.js');
var error = require('../../../../utils/error.js');
var shared = require('@vue/shared');
var event$1 = require('../../../../utils/dom/event.js');
var aria = require('../../../../constants/aria.js');
const __default__ = vue.defineComponent({
name: "Picker"
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
...__default__,
props: props.timePickerDefaultProps,
emits: [
event.UPDATE_MODEL_EVENT,
event.CHANGE_EVENT,
"focus",
"blur",
"clear",
"calendar-change",
"panel-change",
"visible-change",
"keydown"
],
setup(__props, { expose, emit }) {
const props = __props;
const attrs = vue.useAttrs();
const nsDate = index.useNamespace("date");
const nsInput = index.useNamespace("input");
const nsRange = index.useNamespace("range");
const { formItem } = useFormItem.useFormItem();
const elPopperOptions = vue.inject(constants.PICKER_POPPER_OPTIONS_INJECTION_KEY, {});
const emptyValues = index$1.useEmptyValues(props, null);
const refPopper = vue.ref();
const inputRef = vue.ref();
const valueOnOpen = vue.ref(null);
let hasJustTabExitedInput = false;
const pickerDisabled = useFormCommonProps.useFormDisabled();
const commonPicker = useCommonPicker.useCommonPicker(props, emit);
const {
parsedValue,
pickerActualVisible,
userInput,
pickerVisible,
pickerOptions,
valueIsEmpty,
emitInput,
onPick,
onSetPickerOption,
onCalendarChange,
onPanelChange
} = commonPicker;
const { isFocused, handleFocus, handleBlur } = index$2.useFocusController(inputRef, {
disabled: pickerDisabled,
beforeFocus() {
return props.readonly;
},
afterFocus() {
if (!props.automaticDropdown)
return;
pickerVisible.value = true;
},
beforeBlur(event) {
var _a;
return !hasJustTabExitedInput && ((_a = refPopper.value) == null ? void 0 : _a.isFocusInsideContent(event));
},
afterBlur() {
handleChange();
pickerVisible.value = false;
hasJustTabExitedInput = false;
props.validateEvent && (formItem == null ? void 0 : formItem.validate("blur").catch((err) => error.debugWarn()));
}
});
const hovering = vue.ref(false);
const rangeInputKls = vue.computed(() => [
nsDate.b("editor"),
nsDate.bm("editor", props.type),
nsInput.e("wrapper"),
nsDate.is("disabled", pickerDisabled.value),
nsDate.is("active", pickerVisible.value),
nsRange.b("editor"),
pickerSize ? nsRange.bm("editor", pickerSize.value) : "",
attrs.class
]);
const clearIconKls = vue.computed(() => [
nsInput.e("icon"),
nsRange.e("close-icon"),
!showClearBtn.value ? nsRange.em("close-icon", "hidden") : ""
]);
vue.watch(pickerVisible, (val) => {
if (!val) {
userInput.value = null;
vue.nextTick(() => {
emitChange(props.modelValue);
});
} else {
vue.nextTick(() => {
if (val) {
valueOnOpen.value = props.modelValue;
}
});
}
});
const emitChange = (val, isClear) => {
if (isClear || !utils.valueEquals(val, valueOnOpen.value)) {
emit(event.CHANGE_EVENT, val);
isClear && (valueOnOpen.value = val);
props.validateEvent && (formItem == null ? void 0 : formItem.validate("change").catch((err) => error.debugWarn()));
}
};
const emitKeydown = (e) => {
emit("keydown", e);
};
const refInput = vue.computed(() => {
if (inputRef.value) {
return Array.from(inputRef.value.$el.querySelectorAll("input"));
}
return [];
});
const setSelectionRange = (start, end, pos) => {
const _inputs = refInput.value;
if (!_inputs.length)
return;
if (!pos || pos === "min") {
_inputs[0].setSelectionRange(start, end);
_inputs[0].focus();
} else if (pos === "max") {
_inputs[1].setSelectionRange(start, end);
_inputs[1].focus();
}
};
const onBeforeShow = () => {
pickerActualVisible.value = true;
};
const onShow = () => {
emit("visible-change", true);
};
const onHide = () => {
pickerActualVisible.value = false;
pickerVisible.value = false;
emit("visible-change", false);
};
const handleOpen = () => {
pickerVisible.value = true;
};
const handleClose = () => {
pickerVisible.value = false;
};
const displayValue = vue.computed(() => {
const formattedValue = formatToString(parsedValue.value);
if (shared.isArray(userInput.value)) {
return [
userInput.value[0] || formattedValue && formattedValue[0] || "",
userInput.value[1] || formattedValue && formattedValue[1] || ""
];
} else if (userInput.value !== null) {
return userInput.value;
}
if (!isTimePicker.value && valueIsEmpty.value)
return "";
if (!pickerVisible.value && valueIsEmpty.value)
return "";
if (formattedValue) {
return isDatesPicker.value || isMonthsPicker.value || isYearsPicker.value ? formattedValue.join(", ") : formattedValue;
}
return "";
});
const isTimeLikePicker = vue.computed(() => props.type.includes("time"));
const isTimePicker = vue.computed(() => props.type.startsWith("time"));
const isDatesPicker = vue.computed(() => props.type === "dates");
const isMonthsPicker = vue.computed(() => props.type === "months");
const isYearsPicker = vue.computed(() => props.type === "years");
const triggerIcon = vue.computed(() => props.prefixIcon || (isTimeLikePicker.value ? iconsVue.Clock : iconsVue.Calendar));
const showClearBtn = vue.computed(() => props.clearable && !pickerDisabled.value && !props.readonly && !valueIsEmpty.value && (hovering.value || isFocused.value));
const onClearIconClick = (event) => {
if (props.readonly || pickerDisabled.value)
return;
if (showClearBtn.value) {
event.stopPropagation();
if (pickerOptions.value.handleClear) {
pickerOptions.value.handleClear();
} else {
emitInput(emptyValues.valueOnClear.value);
}
emitChange(emptyValues.valueOnClear.value, true);
onHide();
}
emit("clear");
};
const onMouseDownInput = async (event) => {
var _a;
if (props.readonly || pickerDisabled.value)
return;
if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || isFocused.value || !props.automaticDropdown) {
pickerVisible.value = true;
}
};
const onMouseEnter = () => {
if (props.readonly || pickerDisabled.value)
return;
if (!valueIsEmpty.value && props.clearable) {
hovering.value = true;
}
};
const onMouseLeave = () => {
hovering.value = false;
};
const onTouchStartInput = (event) => {
var _a;
if (props.readonly || pickerDisabled.value)
return;
if (((_a = event.touches[0].target) == null ? void 0 : _a.tagName) !== "INPUT" || isFocused.value || !props.automaticDropdown) {
pickerVisible.value = true;
}
};
const isRangeInput = vue.computed(() => {
return props.type.includes("range");
});
const pickerSize = useFormCommonProps.useFormSize();
const popperEl = vue.computed(() => {
var _a, _b;
return (_b = (_a = vue.unref(refPopper)) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
});
const stophandle = core.onClickOutside(inputRef, (e) => {
const unrefedPopperEl = vue.unref(popperEl);
const inputEl = core.unrefElement(inputRef);
if (unrefedPopperEl && (e.target === unrefedPopperEl || e.composedPath().includes(unrefedPopperEl)) || e.target === inputEl || inputEl && e.composedPath().includes(inputEl))
return;
pickerVisible.value = false;
});
vue.onBeforeUnmount(() => {
stophandle == null ? void 0 : stophandle();
});
const handleChange = () => {
if (userInput.value) {
const value = parseUserInputToDayjs(displayValue.value);
if (value) {
if (isValidValue(value)) {
emitInput(utils.dayOrDaysToDate(value));
userInput.value = null;
}
}
}
if (userInput.value === "") {
emitInput(emptyValues.valueOnClear.value);
emitChange(emptyValues.valueOnClear.value, true);
userInput.value = null;
}
};
const parseUserInputToDayjs = (value) => {
if (!value)
return null;
return pickerOptions.value.parseUserInput(value);
};
const formatToString = (value) => {
if (!value)
return null;
const res = shared.isArray(value) ? value.map((_) => _.format(props.format)) : value.format(props.format);
return res;
};
const isValidValue = (value) => {
return pickerOptions.value.isValidValue(value);
};
const handleKeydownInput = async (event) => {
if (props.readonly || pickerDisabled.value)
return;
const code = event$1.getEventCode(event);
emitKeydown(event);
if (code === aria.EVENT_CODE.esc) {
if (pickerVisible.value === true) {
pickerVisible.value = false;
event.preventDefault();
event.stopPropagation();
}
return;
}
if (code === aria.EVENT_CODE.down) {
if (pickerOptions.value.handleFocusPicker) {
event.preventDefault();
event.stopPropagation();
}
if (pickerVisible.value === false) {
pickerVisible.value = true;
await vue.nextTick();
}
if (pickerOptions.value.handleFocusPicker) {
pickerOptions.value.handleFocusPicker();
return;
}
}
if (code === aria.EVENT_CODE.tab) {
hasJustTabExitedInput = true;
return;
}
if (code === aria.EVENT_CODE.enter || code === aria.EVENT_CODE.numpadEnter) {
if (!pickerVisible.value) {
pickerVisible.value = true;
} else if (userInput.value === null || userInput.value === "" || isValidValue(parseUserInputToDayjs(displayValue.value))) {
handleChange();
pickerVisible.value = false;
}
event.preventDefault();
event.stopPropagation();
return;
}
if (userInput.value) {
event.stopPropagation();
return;
}
if (pickerOptions.value.handleKeydownInput) {
pickerOptions.value.handleKeydownInput(event);
}
};
const onUserInput = (e) => {
userInput.value = e;
if (!pickerVisible.value) {
pickerVisible.value = true;
}
};
const handleStartInput = (event) => {
const target = event.target;
if (userInput.value) {
userInput.value = [target.value, userInput.value[1]];
} else {
userInput.value = [target.value, null];
}
};
const handleEndInput = (event) => {
const target = event.target;
if (userInput.value) {
userInput.value = [userInput.value[0], target.value];
} else {
userInput.value = [null, target.value];
}
};
const handleStartChange = () => {
var _a;
const values = userInput.value;
const value = parseUserInputToDayjs(values && values[0]);
const parsedVal = vue.unref(parsedValue);
if (value && value.isValid()) {
userInput.value = [
formatToString(value),
((_a = displayValue.value) == null ? void 0 : _a[1]) || null
];
const newValue = [value, parsedVal && (parsedVal[1] || null)];
if (isValidValue(newValue)) {
emitInput(utils.dayOrDaysToDate(newValue));
userInput.value = null;
}
}
};
const handleEndChange = () => {
var _a;
const values = vue.unref(userInput);
const value = parseUserInputToDayjs(values && values[1]);
const parsedVal = vue.unref(parsedValue);
if (value && value.isValid()) {
userInput.value = [
((_a = vue.unref(displayValue)) == null ? void 0 : _a[0]) || null,
formatToString(value)
];
const newValue = [parsedVal && parsedVal[0], value];
if (isValidValue(newValue)) {
emitInput(utils.dayOrDaysToDate(newValue));
userInput.value = null;
}
}
};
const focus = () => {
var _a;
(_a = inputRef.value) == null ? void 0 : _a.focus();
};
const blur = () => {
var _a;
(_a = inputRef.value) == null ? void 0 : _a.blur();
};
vue.provide(constants.PICKER_BASE_INJECTION_KEY, {
props,
emptyValues
});
vue.provide(constants.ROOT_COMMON_PICKER_INJECTION_KEY, commonPicker);
expose({
focus,
blur,
handleOpen,
handleClose,
onPick
});
return (_ctx, _cache) => {
return vue.openBlock(), vue.createBlock(vue.unref(index$3.ElTooltip), vue.mergeProps({
ref_key: "refPopper",
ref: refPopper,
visible: vue.unref(pickerVisible),
effect: "light",
pure: "",
trigger: "click"
}, _ctx.$attrs, {
role: "dialog",
teleported: "",
transition: `${vue.unref(nsDate).namespace.value}-zoom-in-top`,
"popper-class": [`${vue.unref(nsDate).namespace.value}-picker__popper`, _ctx.popperClass],
"popper-style": _ctx.popperStyle,
"popper-options": vue.unref(elPopperOptions),
"fallback-placements": _ctx.fallbackPlacements,
"gpu-acceleration": false,
placement: _ctx.placement,
"stop-popper-mouse-event": false,
"hide-after": 0,
persistent: "",
onBeforeShow,
onShow,
onHide
}), {
default: vue.withCtx(() => [
!vue.unref(isRangeInput) ? (vue.openBlock(), vue.createBlock(vue.unref(index$4.ElInput), {
key: 0,
id: _ctx.id,
ref_key: "inputRef",
ref: inputRef,
"container-role": "combobox",
"model-value": vue.unref(displayValue),
name: _ctx.name,
size: vue.unref(pickerSize),
disabled: vue.unref(pickerDisabled),
placeholder: _ctx.placeholder,
class: vue.normalizeClass([
vue.unref(nsDate).b("editor"),
vue.unref(nsDate).bm("editor", _ctx.type),
vue.unref(nsDate).is("focus", vue.unref(pickerVisible)),
_ctx.$attrs.class
]),
style: vue.normalizeStyle(_ctx.$attrs.style),
readonly: !_ctx.editable || _ctx.readonly || vue.unref(isDatesPicker) || vue.unref(isMonthsPicker) || vue.unref(isYearsPicker) || _ctx.type === "week",
"aria-label": _ctx.ariaLabel,
tabindex: _ctx.tabindex,
"validate-event": false,
onInput: onUserInput,
onFocus: vue.unref(handleFocus),
onBlur: vue.unref(handleBlur),
onKeydown: handleKeydownInput,
onChange: handleChange,
onMousedown: onMouseDownInput,
onMouseenter: onMouseEnter,
onMouseleave: onMouseLeave,
onTouchstartPassive: onTouchStartInput,
onClick: vue.withModifiers(() => {
}, ["stop"])
}, {
prefix: vue.withCtx(() => [
vue.unref(triggerIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(index$5.ElIcon), {
key: 0,
class: vue.normalizeClass(vue.unref(nsInput).e("icon")),
onMousedown: vue.withModifiers(onMouseDownInput, ["prevent"]),
onTouchstartPassive: onTouchStartInput
}, {
default: vue.withCtx(() => [
(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(triggerIcon))))
]),
_: 1
}, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
]),
suffix: vue.withCtx(() => [
vue.unref(showClearBtn) && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(vue.unref(index$5.ElIcon), {
key: 0,
class: vue.normalizeClass(`${vue.unref(nsInput).e("icon")} clear-icon`),
onMousedown: vue.withModifiers(vue.unref(shared.NOOP), ["prevent"]),
onClick: onClearIconClick
}, {
default: vue.withCtx(() => [
(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
]),
_: 1
}, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
]),
_: 1
}, 8, ["id", "model-value", "name", "size", "disabled", "placeholder", "class", "style", "readonly", "aria-label", "tabindex", "onFocus", "onBlur", "onClick"])) : (vue.openBlock(), vue.createBlock(pickerRangeTrigger["default"], {
key: 1,
id: _ctx.id,
ref_key: "inputRef",
ref: inputRef,
"model-value": vue.unref(displayValue),
name: _ctx.name,
disabled: vue.unref(pickerDisabled),
readonly: !_ctx.editable || _ctx.readonly,
"start-placeholder": _ctx.startPlaceholder,
"end-placeholder": _ctx.endPlaceholder,
class: vue.normalizeClass(vue.unref(rangeInputKls)),
style: vue.normalizeStyle(_ctx.$attrs.style),
"aria-label": _ctx.ariaLabel,
tabindex: _ctx.tabindex,
autocomplete: "off",
role: "combobox",
onClick: onMouseDownInput,
onFocus: vue.unref(handleFocus),
onBlur: vue.unref(handleBlur),
onStartInput: handleStartInput,
onStartChange: handleStartChange,
onEndInput: handleEndInput,
onEndChange: handleEndChange,
onMousedown: onMouseDownInput,
onMouseenter: onMouseEnter,
onMouseleave: onMouseLeave,
onTouchstartPassive: onTouchStartInput,
onKeydown: handleKeydownInput
}, {
prefix: vue.withCtx(() => [
vue.unref(triggerIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(index$5.ElIcon), {
key: 0,
class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsRange).e("icon")])
}, {
default: vue.withCtx(() => [
(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(triggerIcon))))
]),
_: 1
}, 8, ["class"])) : vue.createCommentVNode("v-if", true)
]),
"range-separator": vue.withCtx(() => [
vue.renderSlot(_ctx.$slots, "range-separator", {}, () => [
vue.createElementVNode("span", {
class: vue.normalizeClass(vue.unref(nsRange).b("separator"))
}, vue.toDisplayString(_ctx.rangeSeparator), 3)
])
]),
suffix: vue.withCtx(() => [
_ctx.clearIcon ? (vue.openBlock(), vue.createBlock(vue.unref(index$5.ElIcon), {
key: 0,
class: vue.normalizeClass(vue.unref(clearIconKls)),
onMousedown: vue.withModifiers(vue.unref(shared.NOOP), ["prevent"]),
onClick: onClearIconClick
}, {
default: vue.withCtx(() => [
(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
]),
_: 1
}, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
]),
_: 3
}, 8, ["id", "model-value", "name", "disabled", "readonly", "start-placeholder", "end-placeholder", "class", "style", "aria-label", "tabindex", "onFocus", "onBlur"]))
]),
content: vue.withCtx(() => [
vue.renderSlot(_ctx.$slots, "default", {
visible: vue.unref(pickerVisible),
actualVisible: vue.unref(pickerActualVisible),
parsedValue: vue.unref(parsedValue),
format: _ctx.format,
dateFormat: _ctx.dateFormat,
timeFormat: _ctx.timeFormat,
unlinkPanels: _ctx.unlinkPanels,
type: _ctx.type,
defaultValue: _ctx.defaultValue,
showNow: _ctx.showNow,
showConfirm: _ctx.showConfirm,
showFooter: _ctx.showFooter,
showWeekNumber: _ctx.showWeekNumber,
onPick: vue.unref(onPick),
onSelectRange: setSelectionRange,
onSetPickerOption: vue.unref(onSetPickerOption),
onCalendarChange: vue.unref(onCalendarChange),
onPanelChange: vue.unref(onPanelChange),
onMousedown: vue.withModifiers(() => {
}, ["stop"])
})
]),
_: 3
}, 16, ["visible", "transition", "popper-class", "popper-style", "popper-options", "fallback-placements", "placement"]);
};
}
});
var CommonPicker = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "picker.vue"]]);
exports["default"] = CommonPicker;
//# sourceMappingURL=picker.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/common/picker.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

514
frontend/node_modules/element-plus/lib/components/time-picker/src/common/picker.vue.d.ts generated vendored Normal file
View File

@@ -0,0 +1,514 @@
import type { Options } from '@popperjs/core';
import type { DayOrDays } from './props';
declare function __VLS_template(): {
"range-separator"?(_: {}): any;
default?(_: {
visible: boolean;
actualVisible: boolean;
parsedValue: DayOrDays;
format: string | undefined;
dateFormat: string | undefined;
timeFormat: string | undefined;
unlinkPanels: boolean;
type: string;
defaultValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>))[], unknown, unknown> | undefined;
showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
showConfirm: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
showWeekNumber: boolean;
onMousedown: any;
onPanelChange: any;
onCalendarChange: any;
onSetPickerOption: any;
onSelectRange: any;
onPick: any;
}): any;
};
declare const __VLS_component: import("vue").DefineComponent<{
readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showConfirm: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showWeekNumber: BooleanConstructor;
readonly ariaLabel: StringConstructor;
readonly emptyValues: ArrayConstructor;
readonly valueOnClear: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown, undefined, boolean>;
readonly disabledDate: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly cellClassName: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
readonly arrowControl: BooleanConstructor;
readonly tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly unlinkPanels: BooleanConstructor;
readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("@popperjs/core").Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("@popperjs/core").Placement))[], import("@popperjs/core").Placement, unknown, "bottom", boolean>;
readonly fallbackPlacements: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("@popperjs/core").Placement[]) | (() => import("@popperjs/core").Placement[]) | ((new (...args: any[]) => import("@popperjs/core").Placement[]) | (() => import("@popperjs/core").Placement[]))[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
readonly disabledHours: {
readonly type: import("vue").PropType<import("./props").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<import("./props").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<import("./props").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly automaticDropdown: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly id: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly popperClass: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly popperStyle: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly format: StringConstructor;
readonly valueFormat: StringConstructor;
readonly dateFormat: StringConstructor;
readonly timeFormat: StringConstructor;
readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly clearIcon: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly editable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly prefixIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown, "", boolean>;
readonly size: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly readonly: BooleanConstructor;
readonly disabled: BooleanConstructor;
readonly placeholder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | ((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>))[], unknown, unknown, () => {}, boolean>;
readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./props").ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./props").ModelValueType | null))[], unknown, unknown, "", boolean>;
readonly rangeSeparator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly defaultValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly defaultTime: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly isRange: BooleanConstructor;
}, {
/**
* @description focus input box.
*/
focus: () => void;
/**
* @description blur input box.
*/
blur: () => void;
/**
* @description opens picker
*/
handleOpen: () => void;
/**
* @description closes picker
*/
handleClose: () => void;
/**
* @description pick item manually
*/
onPick: (date?: any, visible?: boolean) => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
focus: (...args: any[]) => void;
"update:modelValue": (...args: any[]) => void;
change: (...args: any[]) => void;
clear: (...args: any[]) => void;
blur: (...args: any[]) => void;
keydown: (...args: any[]) => void;
"calendar-change": (...args: any[]) => void;
"panel-change": (...args: any[]) => void;
"visible-change": (...args: any[]) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showConfirm: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showWeekNumber: BooleanConstructor;
readonly ariaLabel: StringConstructor;
readonly emptyValues: ArrayConstructor;
readonly valueOnClear: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown, undefined, boolean>;
readonly disabledDate: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly cellClassName: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
readonly arrowControl: BooleanConstructor;
readonly tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly unlinkPanels: BooleanConstructor;
readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("@popperjs/core").Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("@popperjs/core").Placement))[], import("@popperjs/core").Placement, unknown, "bottom", boolean>;
readonly fallbackPlacements: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("@popperjs/core").Placement[]) | (() => import("@popperjs/core").Placement[]) | ((new (...args: any[]) => import("@popperjs/core").Placement[]) | (() => import("@popperjs/core").Placement[]))[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
readonly disabledHours: {
readonly type: import("vue").PropType<import("./props").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<import("./props").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<import("./props").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly automaticDropdown: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly id: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly popperClass: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly popperStyle: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly format: StringConstructor;
readonly valueFormat: StringConstructor;
readonly dateFormat: StringConstructor;
readonly timeFormat: StringConstructor;
readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly clearIcon: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly editable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly prefixIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown, "", boolean>;
readonly size: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly readonly: BooleanConstructor;
readonly disabled: BooleanConstructor;
readonly placeholder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | ((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>))[], unknown, unknown, () => {}, boolean>;
readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./props").ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./props").ModelValueType | null))[], unknown, unknown, "", boolean>;
readonly rangeSeparator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly defaultValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly defaultTime: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly isRange: BooleanConstructor;
}>> & {
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onKeydown?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
"onCalendar-change"?: ((...args: any[]) => any) | undefined;
"onPanel-change"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
}, {
readonly disabled: boolean;
readonly tabindex: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>;
readonly type: string;
readonly placeholder: string;
readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./props").ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./props").ModelValueType | null))[], unknown, unknown>;
readonly placement: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("@popperjs/core").Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("@popperjs/core").Placement))[], import("@popperjs/core").Placement, unknown>;
readonly valueOnClear: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown>;
readonly readonly: boolean;
readonly prefixIcon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>;
readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly fallbackPlacements: import("@popperjs/core").Placement[];
readonly popperOptions: Partial<Options>;
readonly automaticDropdown: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly editable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly rangeSeparator: string;
readonly shortcuts: unknown[];
readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly showConfirm: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly showWeekNumber: boolean;
readonly arrowControl: boolean;
readonly unlinkPanels: boolean;
readonly isRange: boolean;
}>;
declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
};

282
frontend/node_modules/element-plus/lib/components/time-picker/src/common/props.d.ts generated vendored Normal file
View File

@@ -0,0 +1,282 @@
import type { Component, ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
import type { Options } from '@popperjs/core';
import type { Dayjs } from 'dayjs';
import type { Placement } from 'element-plus/es/components/popper';
export type SingleOrRange<T> = T | [T, T];
export type DateModelType = number | string | Date;
export type ModelValueType = DateModelType | number[] | string[] | Date[];
export type DayOrDays = SingleOrRange<Dayjs>;
export type DateOrDates = SingleOrRange<Date>;
export type UserInput = SingleOrRange<string | null>;
export type GetDisabledHours = (role: string, comparingDate?: Dayjs) => number[];
export type GetDisabledMinutes = (hour: number, role: string, comparingDate?: Dayjs) => number[];
export type GetDisabledSeconds = (hour: number, minute: number, role: string, comparingDate?: Dayjs) => number[];
export declare const timePickerDefaultProps: {
readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showConfirm: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly showWeekNumber: BooleanConstructor;
readonly ariaLabel: StringConstructor;
readonly emptyValues: ArrayConstructor;
readonly valueOnClear: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown, undefined, boolean>;
readonly disabledDate: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly cellClassName: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
readonly arrowControl: BooleanConstructor;
readonly tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly unlinkPanels: BooleanConstructor;
readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement))[], Placement, unknown, "bottom", boolean>;
readonly fallbackPlacements: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | ((new (...args: any[]) => Placement[]) | (() => Placement[]))[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
readonly disabledHours: {
readonly type: import("vue").PropType<GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly automaticDropdown: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly id: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly popperClass: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly popperStyle: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly format: StringConstructor;
readonly valueFormat: StringConstructor;
readonly dateFormat: StringConstructor;
readonly timeFormat: StringConstructor;
readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly clearIcon: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | ((new (...args: any[]) => (string | Component) & {}) | (() => string | Component))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly editable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly prefixIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | ((new (...args: any[]) => (string | Component) & {}) | (() => string | Component))[], unknown, unknown, "", boolean>;
readonly size: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly readonly: BooleanConstructor;
readonly disabled: BooleanConstructor;
readonly placeholder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
readonly popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | ((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>))[], unknown, unknown, () => {}, boolean>;
readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => ModelValueType | null))[], unknown, unknown, "", boolean>;
readonly rangeSeparator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly defaultValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly defaultTime: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly isRange: BooleanConstructor;
};
export type TimePickerDefaultProps = ExtractPropTypes<typeof timePickerDefaultProps>;
export type TimePickerDefaultPropsPublic = __ExtractPublicPropTypes<typeof timePickerDefaultProps>;
export interface PickerOptions {
isValidValue: (date: DayOrDays) => boolean;
handleKeydownInput: (event: KeyboardEvent) => void;
parseUserInput: (value: UserInput) => DayOrDays;
getRangeAvailableTime: (date: DayOrDays) => DayOrDays;
getDefaultValue: () => DayOrDays;
panelReady: boolean;
handleClear: () => void;
handleFocusPicker?: () => void;
}
export declare const timePickerRangeTriggerProps: {
readonly id: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly modelValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput) | ((new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly disabled: BooleanConstructor;
};
/**
* @deprecated Use `timePickerRangeTriggerProps` instead. This will be removed in future versions.
*/
export declare const timePickerRngeTriggerProps: {
readonly id: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly name: {
readonly type: import("vue").PropType<string[]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly modelValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput) | ((new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly startPlaceholder: StringConstructor;
readonly endPlaceholder: StringConstructor;
readonly disabled: BooleanConstructor;
};

144
frontend/node_modules/element-plus/lib/components/time-picker/src/common/props.js generated vendored Normal file
View File

@@ -0,0 +1,144 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var core = require('@popperjs/core');
var iconsVue = require('@element-plus/icons-vue');
var shared = require('../props/shared.js');
var runtime = require('../../../../utils/vue/props/runtime.js');
var content = require('../../../tooltip/src/content.js');
var index = require('../../../../hooks/use-size/index.js');
var index$1 = require('../../../../hooks/use-empty-values/index.js');
var index$2 = require('../../../../hooks/use-aria/index.js');
const timePickerDefaultProps = runtime.buildProps({
automaticDropdown: {
type: Boolean,
default: true
},
id: {
type: runtime.definePropType([Array, String])
},
name: {
type: runtime.definePropType([Array, String])
},
popperClass: content.useTooltipContentProps.popperClass,
popperStyle: content.useTooltipContentProps.popperStyle,
format: String,
valueFormat: String,
dateFormat: String,
timeFormat: String,
type: {
type: String,
default: ""
},
clearable: {
type: Boolean,
default: true
},
clearIcon: {
type: runtime.definePropType([String, Object]),
default: iconsVue.CircleClose
},
editable: {
type: Boolean,
default: true
},
prefixIcon: {
type: runtime.definePropType([String, Object]),
default: ""
},
size: index.useSizeProp,
readonly: Boolean,
disabled: Boolean,
placeholder: {
type: String,
default: ""
},
popperOptions: {
type: runtime.definePropType(Object),
default: () => ({})
},
modelValue: {
type: runtime.definePropType([Date, Array, String, Number]),
default: ""
},
rangeSeparator: {
type: String,
default: "-"
},
startPlaceholder: String,
endPlaceholder: String,
defaultValue: {
type: runtime.definePropType([Date, Array])
},
defaultTime: {
type: runtime.definePropType([Date, Array])
},
isRange: Boolean,
...shared.disabledTimeListsProps,
disabledDate: {
type: Function
},
cellClassName: {
type: Function
},
shortcuts: {
type: Array,
default: () => []
},
arrowControl: Boolean,
tabindex: {
type: runtime.definePropType([String, Number]),
default: 0
},
validateEvent: {
type: Boolean,
default: true
},
unlinkPanels: Boolean,
placement: {
type: runtime.definePropType(String),
values: core.placements,
default: "bottom"
},
fallbackPlacements: {
type: runtime.definePropType(Array),
default: ["bottom", "top", "right", "left"]
},
...index$1.useEmptyValuesProps,
...index$2.useAriaProps(["ariaLabel"]),
showNow: {
type: Boolean,
default: true
},
showConfirm: {
type: Boolean,
default: true
},
showFooter: {
type: Boolean,
default: true
},
showWeekNumber: Boolean
});
const timePickerRangeTriggerProps = runtime.buildProps({
id: {
type: runtime.definePropType(Array)
},
name: {
type: runtime.definePropType(Array)
},
modelValue: {
type: runtime.definePropType([Array, String])
},
startPlaceholder: String,
endPlaceholder: String,
disabled: Boolean
});
const timePickerRngeTriggerProps = timePickerRangeTriggerProps;
exports.timePickerDefaultProps = timePickerDefaultProps;
exports.timePickerRangeTriggerProps = timePickerRangeTriggerProps;
exports.timePickerRngeTriggerProps = timePickerRngeTriggerProps;
//# sourceMappingURL=props.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/common/props.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

31
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-common-picker.d.ts generated vendored Normal file
View File

@@ -0,0 +1,31 @@
import type { Dayjs } from 'dayjs';
import type { DateModelType, DayOrDays, ModelValueType, PickerOptions, SingleOrRange, UserInput } from '../common/props';
interface CommonPickerProps {
modelValue: ModelValueType | null;
valueFormat?: string;
}
type CommonPickerEmits = (event: 'update:modelValue' | 'calendar-change' | 'panel-change', ...args: any[]) => void;
export declare const useCommonPicker: <P extends CommonPickerProps, E extends CommonPickerEmits>(props: P, emit: E) => {
parsedValue: import("vue").ComputedRef<DayOrDays>;
pickerActualVisible: import("vue").Ref<boolean>;
pickerOptions: import("vue").Ref<{
isValidValue?: ((date: DayOrDays) => boolean) | undefined;
handleKeydownInput?: ((event: KeyboardEvent) => void) | undefined;
parseUserInput?: ((value: UserInput) => DayOrDays) | undefined;
getRangeAvailableTime?: ((date: DayOrDays) => DayOrDays) | undefined;
getDefaultValue?: (() => DayOrDays) | undefined;
panelReady?: boolean | undefined;
handleClear?: (() => void) | undefined;
handleFocusPicker?: (() => void) | undefined;
}>;
pickerVisible: import("vue").Ref<boolean>;
userInput: import("vue").Ref<UserInput>;
valueIsEmpty: import("vue").ComputedRef<boolean>;
emitInput: (input: SingleOrRange<DateModelType> | null) => void;
onCalendarChange: (e: [Date, null | Date]) => void;
onPanelChange: (value: [Dayjs, Dayjs], mode: "month" | "year", view: unknown) => void;
onPick: (date?: any, visible?: boolean) => void;
onSetPickerOption: <T extends keyof PickerOptions>(e: [T, PickerOptions[T]]) => void;
};
export type CommonPickerContext = ReturnType<typeof useCommonPicker>;
export {};

99
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-common-picker.js generated vendored Normal file
View File

@@ -0,0 +1,99 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var lodashUnified = require('lodash-unified');
var index = require('../../../../hooks/use-locale/index.js');
var utils = require('../utils.js');
var shared = require('@vue/shared');
var event = require('../../../../constants/event.js');
const useCommonPicker = (props, emit) => {
const { lang } = index.useLocale();
const pickerVisible = vue.ref(false);
const pickerActualVisible = vue.ref(false);
const userInput = vue.ref(null);
const valueIsEmpty = vue.computed(() => {
const { modelValue } = props;
return !modelValue || shared.isArray(modelValue) && !modelValue.filter(Boolean).length;
});
const emitInput = (input) => {
if (!utils.valueEquals(props.modelValue, input)) {
let formatted;
if (shared.isArray(input)) {
formatted = input.map((item) => utils.formatter(item, props.valueFormat, lang.value));
} else if (input) {
formatted = utils.formatter(input, props.valueFormat, lang.value);
}
const emitVal = input ? formatted : input;
emit(event.UPDATE_MODEL_EVENT, emitVal, lang.value);
}
};
const parsedValue = vue.computed(() => {
var _a;
let dayOrDays;
if (valueIsEmpty.value) {
if (pickerOptions.value.getDefaultValue) {
dayOrDays = pickerOptions.value.getDefaultValue();
}
} else {
if (shared.isArray(props.modelValue)) {
dayOrDays = props.modelValue.map((d) => utils.parseDate(d, props.valueFormat, lang.value));
} else {
dayOrDays = utils.parseDate((_a = props.modelValue) != null ? _a : "", props.valueFormat, lang.value);
}
}
if (pickerOptions.value.getRangeAvailableTime) {
const availableResult = pickerOptions.value.getRangeAvailableTime(dayOrDays);
if (!lodashUnified.isEqual(availableResult, dayOrDays)) {
dayOrDays = availableResult;
if (!valueIsEmpty.value) {
emitInput(utils.dayOrDaysToDate(dayOrDays));
}
}
}
if (shared.isArray(dayOrDays) && dayOrDays.some((day) => !day)) {
dayOrDays = [];
}
return dayOrDays;
});
const pickerOptions = vue.ref({});
const onSetPickerOption = (e) => {
pickerOptions.value[e[0]] = e[1];
pickerOptions.value.panelReady = true;
};
const onCalendarChange = (e) => {
emit("calendar-change", e);
};
const onPanelChange = (value, mode, view) => {
emit("panel-change", value, mode, view);
};
const onPick = (date = "", visible = false) => {
pickerVisible.value = visible;
let result;
if (shared.isArray(date)) {
result = date.map((_) => _.toDate());
} else {
result = date ? date.toDate() : date;
}
userInput.value = null;
emitInput(result);
};
return {
parsedValue,
pickerActualVisible,
pickerOptions,
pickerVisible,
userInput,
valueIsEmpty,
emitInput,
onCalendarChange,
onPanelChange,
onPick,
onSetPickerOption
};
};
exports.useCommonPicker = useCommonPicker;
//# sourceMappingURL=use-common-picker.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-common-picker.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

13
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-time-panel.d.ts generated vendored Normal file
View File

@@ -0,0 +1,13 @@
import type { Dayjs } from 'dayjs';
import type { GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds } from '../common/props';
type UseTimePanelProps = {
getAvailableHours: GetDisabledHours;
getAvailableMinutes: GetDisabledMinutes;
getAvailableSeconds: GetDisabledSeconds;
};
export declare const useTimePanel: ({ getAvailableHours, getAvailableMinutes, getAvailableSeconds, }: UseTimePanelProps) => {
timePickerOptions: Record<string, (...args: any[]) => void>;
getAvailableTime: (date: Dayjs, role: string, first: boolean, compareDate?: Dayjs) => Dayjs;
onSetOption: ([key, val]: [string, (...args: any[]) => void]) => void;
};
export {};

55
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-time-panel.js generated vendored Normal file
View File

@@ -0,0 +1,55 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
const useTimePanel = ({
getAvailableHours,
getAvailableMinutes,
getAvailableSeconds
}) => {
const getAvailableTime = (date, role, first, compareDate) => {
const availableTimeGetters = {
hour: getAvailableHours,
minute: getAvailableMinutes,
second: getAvailableSeconds
};
let result = date;
["hour", "minute", "second"].forEach((type) => {
if (availableTimeGetters[type]) {
let availableTimeSlots;
const method = availableTimeGetters[type];
switch (type) {
case "minute": {
availableTimeSlots = method(result.hour(), role, compareDate);
break;
}
case "second": {
availableTimeSlots = method(result.hour(), result.minute(), role, compareDate);
break;
}
default: {
availableTimeSlots = method(role, compareDate);
break;
}
}
if ((availableTimeSlots == null ? void 0 : availableTimeSlots.length) && !availableTimeSlots.includes(result[type]())) {
const pos = first ? 0 : availableTimeSlots.length - 1;
result = result[type](availableTimeSlots[pos]);
}
}
});
return result;
};
const timePickerOptions = {};
const onSetOption = ([key, val]) => {
timePickerOptions[key] = val;
};
return {
timePickerOptions,
getAvailableTime,
onSetOption
};
};
exports.useTimePanel = useTimePanel;
//# sourceMappingURL=use-time-panel.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-time-panel.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"use-time-panel.js","sources":["../../../../../../../packages/components/time-picker/src/composables/use-time-panel.ts"],"sourcesContent":["import type { Dayjs } from 'dayjs'\nimport type {\n GetDisabledHours,\n GetDisabledMinutes,\n GetDisabledSeconds,\n} from '../common/props'\n\ntype UseTimePanelProps = {\n getAvailableHours: GetDisabledHours\n getAvailableMinutes: GetDisabledMinutes\n getAvailableSeconds: GetDisabledSeconds\n}\n\nexport const useTimePanel = ({\n getAvailableHours,\n getAvailableMinutes,\n getAvailableSeconds,\n}: UseTimePanelProps) => {\n const getAvailableTime = (\n date: Dayjs,\n role: string,\n first: boolean,\n compareDate?: Dayjs\n ) => {\n const availableTimeGetters = {\n hour: getAvailableHours,\n minute: getAvailableMinutes,\n second: getAvailableSeconds,\n } as const\n let result = date\n ;(['hour', 'minute', 'second'] as const).forEach((type) => {\n if (availableTimeGetters[type]) {\n let availableTimeSlots: number[]\n const method = availableTimeGetters[type]\n switch (type) {\n case 'minute': {\n availableTimeSlots = (method as typeof getAvailableMinutes)(\n result.hour(),\n role,\n compareDate\n )\n break\n }\n case 'second': {\n availableTimeSlots = (method as typeof getAvailableSeconds)(\n result.hour(),\n result.minute(),\n role,\n compareDate\n )\n break\n }\n default: {\n availableTimeSlots = (method as typeof getAvailableHours)(\n role,\n compareDate\n )\n break\n }\n }\n\n if (\n availableTimeSlots?.length &&\n !availableTimeSlots.includes(result[type]())\n ) {\n const pos = first ? 0 : availableTimeSlots.length - 1\n result = result[type](availableTimeSlots[pos]) as unknown as Dayjs\n }\n }\n })\n return result\n }\n\n const timePickerOptions: Record<string, (...args: any[]) => void> = {}\n\n const onSetOption = ([key, val]: [string, (...args: any[]) => void]) => {\n timePickerOptions[key] = val\n }\n\n return {\n timePickerOptions,\n\n getAvailableTime,\n onSetOption,\n }\n}\n"],"names":[],"mappings":";;;;AAAY,MAAC,YAAY,GAAG,CAAC;AAC7B,EAAE,iBAAiB;AACnB,EAAE,mBAAmB;AACrB,EAAE,mBAAmB;AACrB,CAAC,KAAK;AACN,EAAE,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,KAAK;AAC/D,IAAI,MAAM,oBAAoB,GAAG;AACjC,MAAM,IAAI,EAAE,iBAAiB;AAC7B,MAAM,MAAM,EAAE,mBAAmB;AACjC,MAAM,MAAM,EAAE,mBAAmB;AACjC,KAAK,CAAC;AACN,IAAI,IAAI,MAAM,GAAG,IAAI,CAAC;AACtB,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK;AACnD,MAAM,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE;AACtC,QAAQ,IAAI,kBAAkB,CAAC;AAC/B,QAAQ,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;AAClD,QAAQ,QAAQ,IAAI;AACpB,UAAU,KAAK,QAAQ,EAAE;AACzB,YAAY,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AAC1E,YAAY,MAAM;AAClB,WAAW;AACX,UAAU,KAAK,QAAQ,EAAE;AACzB,YAAY,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AAC3F,YAAY,MAAM;AAClB,WAAW;AACX,UAAU,SAAS;AACnB,YAAY,kBAAkB,GAAG,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AAC3D,YAAY,MAAM;AAClB,WAAW;AACX,SAAS;AACT,QAAQ,IAAI,CAAC,kBAAkB,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,kBAAkB,CAAC,MAAM,KAAK,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;AAC/H,UAAU,MAAM,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC;AAChE,UAAU,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;AACzD,SAAS;AACT,OAAO;AACP,KAAK,CAAC,CAAC;AACP,IAAI,OAAO,MAAM,CAAC;AAClB,GAAG,CAAC;AACJ,EAAE,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAC/B,EAAE,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK;AACtC,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;AACjC,GAAG,CAAC;AACJ,EAAE,OAAO;AACT,IAAI,iBAAiB;AACrB,IAAI,gBAAgB;AACpB,IAAI,WAAW;AACf,GAAG,CAAC;AACJ;;;;"}

156
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-time-picker.d.ts generated vendored Normal file
View File

@@ -0,0 +1,156 @@
import type { Dayjs } from 'dayjs';
import type { GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds } from '../common/props';
export declare const getTimeLists: (disabledHours?: GetDisabledHours, disabledMinutes?: GetDisabledMinutes, disabledSeconds?: GetDisabledSeconds) => {
getHoursList: (role: string, compare?: Dayjs) => boolean[];
getMinutesList: (hour: number, role: string, compare?: Dayjs) => boolean[];
getSecondsList: (hour: number, minute: number, role: string, compare?: Dayjs) => boolean[];
};
export declare const buildAvailableTimeSlotGetter: (disabledHours: GetDisabledHours, disabledMinutes: GetDisabledMinutes, disabledSeconds: GetDisabledSeconds) => {
getAvailableHours: GetDisabledHours;
getAvailableMinutes: GetDisabledMinutes;
getAvailableSeconds: GetDisabledSeconds;
};
export declare const useOldValue: (props: {
parsedValue?: string | Dayjs | Dayjs[];
visible: boolean;
}) => import("vue").Ref<string | {
clone: () => Dayjs;
isValid: () => boolean;
year: {
(): number;
(value: number): Dayjs;
};
month: {
(): number;
(value: number): Dayjs;
};
date: {
(): number;
(value: number): Dayjs;
};
day: {
(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
(value: number): Dayjs;
};
hour: {
(): number;
(value: number): Dayjs;
};
minute: {
(): number;
(value: number): Dayjs;
};
second: {
(): number;
(value: number): Dayjs;
};
millisecond: {
(): number;
(value: number): Dayjs;
};
set: (unit: import("dayjs").UnitType, value: number) => Dayjs;
get: (unit: import("dayjs").UnitType) => number;
add: (value: number, unit?: import("dayjs").ManipulateType) => Dayjs;
subtract: (value: number, unit?: import("dayjs").ManipulateType) => Dayjs;
startOf: (unit: import("dayjs").OpUnitType) => Dayjs;
endOf: (unit: import("dayjs").OpUnitType) => Dayjs;
format: (template?: string) => string;
diff: (date?: import("dayjs").ConfigType, unit?: import("dayjs").QUnitType | import("dayjs").OpUnitType, float?: boolean) => number;
valueOf: () => number;
unix: () => number;
daysInMonth: () => number;
toDate: () => Date;
toJSON: () => string;
toISOString: () => string;
toString: () => string;
utcOffset: () => number;
isBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSame: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
locale: {
(): string;
(preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
};
localeData: () => import("dayjs").InstanceLocaleDataReturn;
week: {
(): number;
(value: number): Dayjs;
};
weekYear: () => number;
dayOfYear: {
(): number;
(value: number): Dayjs;
};
isSameOrAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSameOrBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
} | {
clone: () => Dayjs;
isValid: () => boolean;
year: {
(): number;
(value: number): Dayjs;
};
month: {
(): number;
(value: number): Dayjs;
};
date: {
(): number;
(value: number): Dayjs;
};
day: {
(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
(value: number): Dayjs;
};
hour: {
(): number;
(value: number): Dayjs;
};
minute: {
(): number;
(value: number): Dayjs;
};
second: {
(): number;
(value: number): Dayjs;
};
millisecond: {
(): number;
(value: number): Dayjs;
};
set: (unit: import("dayjs").UnitType, value: number) => Dayjs;
get: (unit: import("dayjs").UnitType) => number;
add: (value: number, unit?: import("dayjs").ManipulateType) => Dayjs;
subtract: (value: number, unit?: import("dayjs").ManipulateType) => Dayjs;
startOf: (unit: import("dayjs").OpUnitType) => Dayjs;
endOf: (unit: import("dayjs").OpUnitType) => Dayjs;
format: (template?: string) => string;
diff: (date?: import("dayjs").ConfigType, unit?: import("dayjs").QUnitType | import("dayjs").OpUnitType, float?: boolean) => number;
valueOf: () => number;
unix: () => number;
daysInMonth: () => number;
toDate: () => Date;
toJSON: () => string;
toISOString: () => string;
toString: () => string;
utcOffset: () => number;
isBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSame: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
locale: {
(): string;
(preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
};
localeData: () => import("dayjs").InstanceLocaleDataReturn;
week: {
(): number;
(value: number): Dayjs;
};
weekYear: () => number;
dayOfYear: {
(): number;
(value: number): Dayjs;
};
isSameOrAfter: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
isSameOrBefore: (date?: import("dayjs").ConfigType, unit?: import("dayjs").OpUnitType) => boolean;
}[] | undefined>;

59
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-time-picker.js generated vendored Normal file
View File

@@ -0,0 +1,59 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var utils = require('../utils.js');
const makeAvailableArr = (disabledList) => {
const trueOrNumber = (isDisabled, index) => isDisabled || index;
const getNumber = (predicate) => predicate !== true;
return disabledList.map(trueOrNumber).filter(getNumber);
};
const getTimeLists = (disabledHours, disabledMinutes, disabledSeconds) => {
const getHoursList = (role, compare) => {
return utils.makeList(24, disabledHours && (() => disabledHours == null ? void 0 : disabledHours(role, compare)));
};
const getMinutesList = (hour, role, compare) => {
return utils.makeList(60, disabledMinutes && (() => disabledMinutes == null ? void 0 : disabledMinutes(hour, role, compare)));
};
const getSecondsList = (hour, minute, role, compare) => {
return utils.makeList(60, disabledSeconds && (() => disabledSeconds == null ? void 0 : disabledSeconds(hour, minute, role, compare)));
};
return {
getHoursList,
getMinutesList,
getSecondsList
};
};
const buildAvailableTimeSlotGetter = (disabledHours, disabledMinutes, disabledSeconds) => {
const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(disabledHours, disabledMinutes, disabledSeconds);
const getAvailableHours = (role, compare) => {
return makeAvailableArr(getHoursList(role, compare));
};
const getAvailableMinutes = (hour, role, compare) => {
return makeAvailableArr(getMinutesList(hour, role, compare));
};
const getAvailableSeconds = (hour, minute, role, compare) => {
return makeAvailableArr(getSecondsList(hour, minute, role, compare));
};
return {
getAvailableHours,
getAvailableMinutes,
getAvailableSeconds
};
};
const useOldValue = (props) => {
const oldValue = vue.ref(props.parsedValue);
vue.watch(() => props.visible, (val) => {
if (!val) {
oldValue.value = props.parsedValue;
}
});
return oldValue;
};
exports.buildAvailableTimeSlotGetter = buildAvailableTimeSlotGetter;
exports.getTimeLists = getTimeLists;
exports.useOldValue = useOldValue;
//# sourceMappingURL=use-time-picker.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/composables/use-time-picker.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"use-time-picker.js","sources":["../../../../../../../packages/components/time-picker/src/composables/use-time-picker.ts"],"sourcesContent":["import { ref, watch } from 'vue'\nimport { makeList } from '../utils'\n\nimport type { Dayjs } from 'dayjs'\nimport type {\n GetDisabledHours,\n GetDisabledMinutes,\n GetDisabledSeconds,\n} from '../common/props'\n\nconst makeAvailableArr = (disabledList: boolean[]): number[] => {\n const trueOrNumber = (isDisabled: boolean, index: number) =>\n isDisabled || index\n\n const getNumber = (predicate: number | true): predicate is number =>\n predicate !== true\n\n return disabledList.map(trueOrNumber).filter(getNumber)\n}\n\nexport const getTimeLists = (\n disabledHours?: GetDisabledHours,\n disabledMinutes?: GetDisabledMinutes,\n disabledSeconds?: GetDisabledSeconds\n) => {\n const getHoursList = (role: string, compare?: Dayjs) => {\n return makeList(24, disabledHours && (() => disabledHours?.(role, compare)))\n }\n\n const getMinutesList = (hour: number, role: string, compare?: Dayjs) => {\n return makeList(\n 60,\n disabledMinutes && (() => disabledMinutes?.(hour, role, compare))\n )\n }\n\n const getSecondsList = (\n hour: number,\n minute: number,\n role: string,\n compare?: Dayjs\n ) => {\n return makeList(\n 60,\n disabledSeconds && (() => disabledSeconds?.(hour, minute, role, compare))\n )\n }\n\n return {\n getHoursList,\n getMinutesList,\n getSecondsList,\n }\n}\n\nexport const buildAvailableTimeSlotGetter = (\n disabledHours: GetDisabledHours,\n disabledMinutes: GetDisabledMinutes,\n disabledSeconds: GetDisabledSeconds\n) => {\n const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(\n disabledHours,\n disabledMinutes,\n disabledSeconds\n )\n\n const getAvailableHours: GetDisabledHours = (role, compare?) => {\n return makeAvailableArr(getHoursList(role, compare))\n }\n\n const getAvailableMinutes: GetDisabledMinutes = (hour, role, compare?) => {\n return makeAvailableArr(getMinutesList(hour, role, compare))\n }\n\n const getAvailableSeconds: GetDisabledSeconds = (\n hour,\n minute,\n role,\n compare?\n ) => {\n return makeAvailableArr(getSecondsList(hour, minute, role, compare))\n }\n\n return {\n getAvailableHours,\n getAvailableMinutes,\n getAvailableSeconds,\n }\n}\n\nexport const useOldValue = (props: {\n parsedValue?: string | Dayjs | Dayjs[]\n visible: boolean\n}) => {\n const oldValue = ref(props.parsedValue)\n\n watch(\n () => props.visible,\n (val) => {\n if (!val) {\n oldValue.value = props.parsedValue\n }\n }\n )\n\n return oldValue\n}\n"],"names":["makeList","ref","watch"],"mappings":";;;;;;;AAEA,MAAM,gBAAgB,GAAG,CAAC,YAAY,KAAK;AAC3C,EAAE,MAAM,YAAY,GAAG,CAAC,UAAU,EAAE,KAAK,KAAK,UAAU,IAAI,KAAK,CAAC;AAClE,EAAE,MAAM,SAAS,GAAG,CAAC,SAAS,KAAK,SAAS,KAAK,IAAI,CAAC;AACtD,EAAE,OAAO,YAAY,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC1D,CAAC,CAAC;AACU,MAAC,YAAY,GAAG,CAAC,aAAa,EAAE,eAAe,EAAE,eAAe,KAAK;AACjF,EAAE,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK;AAC1C,IAAI,OAAOA,cAAQ,CAAC,EAAE,EAAE,aAAa,KAAK,MAAM,aAAa,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AAChH,GAAG,CAAC;AACJ,EAAE,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,KAAK;AAClD,IAAI,OAAOA,cAAQ,CAAC,EAAE,EAAE,eAAe,KAAK,MAAM,eAAe,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AAC5H,GAAG,CAAC;AACJ,EAAE,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK;AAC1D,IAAI,OAAOA,cAAQ,CAAC,EAAE,EAAE,eAAe,KAAK,MAAM,eAAe,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AACpI,GAAG,CAAC;AACJ,EAAE,OAAO;AACT,IAAI,YAAY;AAChB,IAAI,cAAc;AAClB,IAAI,cAAc;AAClB,GAAG,CAAC;AACJ,EAAE;AACU,MAAC,4BAA4B,GAAG,CAAC,aAAa,EAAE,eAAe,EAAE,eAAe,KAAK;AACjG,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,GAAG,YAAY,CAAC,aAAa,EAAE,eAAe,EAAE,eAAe,CAAC,CAAC;AACzH,EAAE,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK;AAC/C,IAAI,OAAO,gBAAgB,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACzD,GAAG,CAAC;AACJ,EAAE,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,KAAK;AACvD,IAAI,OAAO,gBAAgB,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACjE,GAAG,CAAC;AACJ,EAAE,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK;AAC/D,IAAI,OAAO,gBAAgB,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACzE,GAAG,CAAC;AACJ,EAAE,OAAO;AACT,IAAI,iBAAiB;AACrB,IAAI,mBAAmB;AACvB,IAAI,mBAAmB;AACvB,GAAG,CAAC;AACJ,EAAE;AACU,MAAC,WAAW,GAAG,CAAC,KAAK,KAAK;AACtC,EAAE,MAAM,QAAQ,GAAGC,OAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAC1C,EAAEC,SAAK,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK;AACtC,IAAI,IAAI,CAAC,GAAG,EAAE;AACd,MAAM,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC;AACzC,KAAK;AACL,GAAG,CAAC,CAAC;AACL,EAAE,OAAO,QAAQ,CAAC;AAClB;;;;;;"}

23
frontend/node_modules/element-plus/lib/components/time-picker/src/constants.d.ts generated vendored Normal file
View File

@@ -0,0 +1,23 @@
import type { InjectionKey } from 'vue';
import type { CommonPickerContext } from './composables/use-common-picker';
export declare const timeUnits: readonly ["hours", "minutes", "seconds"];
export declare const PICKER_BASE_INJECTION_KEY = "EP_PICKER_BASE";
export declare const PICKER_POPPER_OPTIONS_INJECTION_KEY = "ElPopperOptions";
export declare const ROOT_COMMON_PICKER_INJECTION_KEY: InjectionKey<CommonPickerContext>;
export declare const DEFAULT_FORMATS_TIME = "HH:mm:ss";
export declare const DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
export declare const DEFAULT_FORMATS_DATEPICKER: {
date: string;
dates: string;
week: string;
year: string;
years: string;
month: string;
months: string;
datetime: string;
monthrange: string;
yearrange: string;
daterange: string;
datetimerange: string;
};
export type TimeUnit = (typeof timeUnits)[number];

33
frontend/node_modules/element-plus/lib/components/time-picker/src/constants.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
const timeUnits = ["hours", "minutes", "seconds"];
const PICKER_BASE_INJECTION_KEY = "EP_PICKER_BASE";
const PICKER_POPPER_OPTIONS_INJECTION_KEY = "ElPopperOptions";
const ROOT_COMMON_PICKER_INJECTION_KEY = Symbol("commonPickerContextKey");
const DEFAULT_FORMATS_TIME = "HH:mm:ss";
const DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
const DEFAULT_FORMATS_DATEPICKER = {
date: DEFAULT_FORMATS_DATE,
dates: DEFAULT_FORMATS_DATE,
week: "gggg[w]ww",
year: "YYYY",
years: "YYYY",
month: "YYYY-MM",
months: "YYYY-MM",
datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,
monthrange: "YYYY-MM",
yearrange: "YYYY",
daterange: DEFAULT_FORMATS_DATE,
datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`
};
exports.DEFAULT_FORMATS_DATE = DEFAULT_FORMATS_DATE;
exports.DEFAULT_FORMATS_DATEPICKER = DEFAULT_FORMATS_DATEPICKER;
exports.DEFAULT_FORMATS_TIME = DEFAULT_FORMATS_TIME;
exports.PICKER_BASE_INJECTION_KEY = PICKER_BASE_INJECTION_KEY;
exports.PICKER_POPPER_OPTIONS_INJECTION_KEY = PICKER_POPPER_OPTIONS_INJECTION_KEY;
exports.ROOT_COMMON_PICKER_INJECTION_KEY = ROOT_COMMON_PICKER_INJECTION_KEY;
exports.timeUnits = timeUnits;
//# sourceMappingURL=constants.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/constants.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"constants.js","sources":["../../../../../../packages/components/time-picker/src/constants.ts"],"sourcesContent":["import type { InjectionKey } from 'vue'\nimport type { CommonPickerContext } from './composables/use-common-picker'\n\nexport const timeUnits = ['hours', 'minutes', 'seconds'] as const\n\nexport const PICKER_BASE_INJECTION_KEY = 'EP_PICKER_BASE'\n\nexport const PICKER_POPPER_OPTIONS_INJECTION_KEY = 'ElPopperOptions'\n\nexport const ROOT_COMMON_PICKER_INJECTION_KEY: InjectionKey<CommonPickerContext> =\n Symbol('commonPickerContextKey')\n\nexport const DEFAULT_FORMATS_TIME = 'HH:mm:ss'\n\nexport const DEFAULT_FORMATS_DATE = 'YYYY-MM-DD'\n\nexport const DEFAULT_FORMATS_DATEPICKER = {\n date: DEFAULT_FORMATS_DATE,\n dates: DEFAULT_FORMATS_DATE,\n week: 'gggg[w]ww',\n year: 'YYYY',\n years: 'YYYY',\n month: 'YYYY-MM',\n months: 'YYYY-MM',\n datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,\n monthrange: 'YYYY-MM',\n yearrange: 'YYYY',\n daterange: DEFAULT_FORMATS_DATE,\n datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,\n}\n\nexport type TimeUnit = (typeof timeUnits)[number]\n"],"names":[],"mappings":";;;;AAAY,MAAC,SAAS,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE;AAC7C,MAAC,yBAAyB,GAAG,iBAAiB;AAC9C,MAAC,mCAAmC,GAAG,kBAAkB;AACzD,MAAC,gCAAgC,GAAG,MAAM,CAAC,wBAAwB,EAAE;AACrE,MAAC,oBAAoB,GAAG,WAAW;AACnC,MAAC,oBAAoB,GAAG,aAAa;AACrC,MAAC,0BAA0B,GAAG;AAC1C,EAAE,IAAI,EAAE,oBAAoB;AAC5B,EAAE,KAAK,EAAE,oBAAoB;AAC7B,EAAE,IAAI,EAAE,WAAW;AACnB,EAAE,IAAI,EAAE,MAAM;AACd,EAAE,KAAK,EAAE,MAAM;AACf,EAAE,KAAK,EAAE,SAAS;AAClB,EAAE,MAAM,EAAE,SAAS;AACnB,EAAE,QAAQ,EAAE,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;AAC7D,EAAE,UAAU,EAAE,SAAS;AACvB,EAAE,SAAS,EAAE,MAAM;AACnB,EAAE,SAAS,EAAE,oBAAoB;AACjC,EAAE,aAAa,EAAE,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;AAClE;;;;;;;;;;"}

39
frontend/node_modules/element-plus/lib/components/time-picker/src/props/basic-time-spinner.d.ts generated vendored Normal file
View File

@@ -0,0 +1,39 @@
import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
import type { Dayjs } from 'dayjs';
export declare const basicTimeSpinnerProps: {
readonly disabledHours: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly role: {
readonly type: import("vue").PropType<string>;
readonly required: true;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly spinnerDate: {
readonly type: import("vue").PropType<Dayjs>;
readonly required: true;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly showSeconds: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly arrowControl: BooleanConstructor;
readonly amPmMode: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | ((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A"))[], unknown, unknown, "", boolean>;
};
export type BasicTimeSpinnerProps = ExtractPropTypes<typeof basicTimeSpinnerProps>;
export type BasicTimeSpinnerPropsPublic = __ExtractPublicPropTypes<typeof basicTimeSpinnerProps>;

30
frontend/node_modules/element-plus/lib/components/time-picker/src/props/basic-time-spinner.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var shared = require('./shared.js');
var runtime = require('../../../../utils/vue/props/runtime.js');
const basicTimeSpinnerProps = runtime.buildProps({
role: {
type: String,
required: true
},
spinnerDate: {
type: runtime.definePropType(Object),
required: true
},
showSeconds: {
type: Boolean,
default: true
},
arrowControl: Boolean,
amPmMode: {
type: runtime.definePropType(String),
default: ""
},
...shared.disabledTimeListsProps
});
exports.basicTimeSpinnerProps = basicTimeSpinnerProps;
//# sourceMappingURL=basic-time-spinner.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/props/basic-time-spinner.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"basic-time-spinner.js","sources":["../../../../../../../packages/components/time-picker/src/props/basic-time-spinner.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { disabledTimeListsProps } from '../props/shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const basicTimeSpinnerProps = buildProps({\n role: {\n type: String,\n required: true,\n },\n spinnerDate: {\n type: definePropType<Dayjs>(Object),\n required: true,\n },\n showSeconds: {\n type: Boolean,\n default: true,\n },\n arrowControl: Boolean,\n amPmMode: {\n // 'a': am/pm; 'A': AM/PM\n type: definePropType<'a' | 'A' | ''>(String),\n default: '',\n },\n ...disabledTimeListsProps,\n} as const)\n\nexport type BasicTimeSpinnerProps = ExtractPropTypes<\n typeof basicTimeSpinnerProps\n>\nexport type BasicTimeSpinnerPropsPublic = __ExtractPublicPropTypes<\n typeof basicTimeSpinnerProps\n>\n"],"names":["buildProps","definePropType","disabledTimeListsProps"],"mappings":";;;;;;;AAEY,MAAC,qBAAqB,GAAGA,kBAAU,CAAC;AAChD,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,QAAQ,EAAE,IAAI;AAClB,GAAG;AACH,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEC,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,QAAQ,EAAE,IAAI;AAClB,GAAG;AACH,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,YAAY,EAAE,OAAO;AACvB,EAAE,QAAQ,EAAE;AACZ,IAAI,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,GAAGC,6BAAsB;AAC3B,CAAC;;;;"}

16
frontend/node_modules/element-plus/lib/components/time-picker/src/props/panel-time-picker.d.ts generated vendored Normal file
View File

@@ -0,0 +1,16 @@
import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
import type { Dayjs } from 'dayjs';
export declare const panelTimePickerProps: {
readonly datetimeRole: StringConstructor;
readonly parsedValue: {
readonly type: import("vue").PropType<Dayjs>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
};
export type PanelTimePickerProps = ExtractPropTypes<typeof panelTimePickerProps>;
export type PanelTimePickerPropsPublic = __ExtractPublicPropTypes<typeof panelTimePickerProps>;

17
frontend/node_modules/element-plus/lib/components/time-picker/src/props/panel-time-picker.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var shared = require('./shared.js');
var runtime = require('../../../../utils/vue/props/runtime.js');
const panelTimePickerProps = runtime.buildProps({
...shared.timePanelSharedProps,
datetimeRole: String,
parsedValue: {
type: runtime.definePropType(Object)
}
});
exports.panelTimePickerProps = panelTimePickerProps;
//# sourceMappingURL=panel-time-picker.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/props/panel-time-picker.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"panel-time-picker.js","sources":["../../../../../../../packages/components/time-picker/src/props/panel-time-picker.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { timePanelSharedProps } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const panelTimePickerProps = buildProps({\n ...timePanelSharedProps,\n datetimeRole: String,\n parsedValue: {\n type: definePropType<Dayjs>(Object),\n },\n} as const)\n\nexport type PanelTimePickerProps = ExtractPropTypes<typeof panelTimePickerProps>\nexport type PanelTimePickerPropsPublic = __ExtractPublicPropTypes<\n typeof panelTimePickerProps\n>\n"],"names":["buildProps","timePanelSharedProps","definePropType"],"mappings":";;;;;;;AAEY,MAAC,oBAAoB,GAAGA,kBAAU,CAAC;AAC/C,EAAE,GAAGC,2BAAoB;AACzB,EAAE,YAAY,EAAE,MAAM;AACtB,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEC,sBAAc,CAAC,MAAM,CAAC;AAChC,GAAG;AACH,CAAC;;;;"}

15
frontend/node_modules/element-plus/lib/components/time-picker/src/props/panel-time-range.d.ts generated vendored Normal file
View File

@@ -0,0 +1,15 @@
import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
import type { Dayjs } from 'dayjs';
export declare const panelTimeRangeProps: {
readonly parsedValue: {
readonly type: import("vue").PropType<[Dayjs, Dayjs]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
};
export type PanelTimeRangeProps = ExtractPropTypes<typeof panelTimeRangeProps>;
export type PanelTimeRangePropsPublic = __ExtractPublicPropTypes<typeof panelTimeRangeProps>;

16
frontend/node_modules/element-plus/lib/components/time-picker/src/props/panel-time-range.js generated vendored Normal file
View File

@@ -0,0 +1,16 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var shared = require('./shared.js');
var runtime = require('../../../../utils/vue/props/runtime.js');
const panelTimeRangeProps = runtime.buildProps({
...shared.timePanelSharedProps,
parsedValue: {
type: runtime.definePropType(Array)
}
});
exports.panelTimeRangeProps = panelTimeRangeProps;
//# sourceMappingURL=panel-time-range.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/props/panel-time-range.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"panel-time-range.js","sources":["../../../../../../../packages/components/time-picker/src/props/panel-time-range.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { timePanelSharedProps } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const panelTimeRangeProps = buildProps({\n ...timePanelSharedProps,\n parsedValue: {\n type: definePropType<[Dayjs, Dayjs]>(Array),\n },\n} as const)\n\nexport type PanelTimeRangeProps = ExtractPropTypes<typeof panelTimeRangeProps>\nexport type PanelTimeRangePropsPublic = __ExtractPublicPropTypes<\n typeof panelTimeRangeProps\n>\n"],"names":["buildProps","timePanelSharedProps","definePropType"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAGA,kBAAU,CAAC;AAC9C,EAAE,GAAGC,2BAAoB;AACzB,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEC,sBAAc,CAAC,KAAK,CAAC;AAC/B,GAAG;AACH,CAAC;;;;"}

31
frontend/node_modules/element-plus/lib/components/time-picker/src/props/shared.d.ts generated vendored Normal file
View File

@@ -0,0 +1,31 @@
import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
import type { GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds } from '../common/props';
export declare const disabledTimeListsProps: {
readonly disabledHours: {
readonly type: import("vue").PropType<GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
};
export type DisabledTimeListsProps = ExtractPropTypes<typeof disabledTimeListsProps>;
export type DisabledTimeListsPropsPublic = __ExtractPublicPropTypes<typeof disabledTimeListsProps>;
export declare const timePanelSharedProps: {
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
};
export type TimePanelSharedProps = ExtractPropTypes<typeof timePanelSharedProps>;
export type TimePanelSharedPropsPublic = __ExtractPublicPropTypes<typeof timePanelSharedProps>;

32
frontend/node_modules/element-plus/lib/components/time-picker/src/props/shared.js generated vendored Normal file
View File

@@ -0,0 +1,32 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var runtime = require('../../../../utils/vue/props/runtime.js');
const disabledTimeListsProps = runtime.buildProps({
disabledHours: {
type: runtime.definePropType(Function)
},
disabledMinutes: {
type: runtime.definePropType(Function)
},
disabledSeconds: {
type: runtime.definePropType(Function)
}
});
const timePanelSharedProps = runtime.buildProps({
visible: Boolean,
actualVisible: {
type: Boolean,
default: void 0
},
format: {
type: String,
default: ""
}
});
exports.disabledTimeListsProps = disabledTimeListsProps;
exports.timePanelSharedProps = timePanelSharedProps;
//# sourceMappingURL=shared.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/props/shared.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"shared.js","sources":["../../../../../../../packages/components/time-picker/src/props/shared.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type {\n GetDisabledHours,\n GetDisabledMinutes,\n GetDisabledSeconds,\n} from '../common/props'\n\nexport const disabledTimeListsProps = buildProps({\n /**\n * @description To specify the array of hours that cannot be selected\n */\n disabledHours: {\n type: definePropType<GetDisabledHours>(Function),\n },\n /**\n * @description To specify the array of minutes that cannot be selected\n */\n disabledMinutes: {\n type: definePropType<GetDisabledMinutes>(Function),\n },\n /**\n * @description To specify the array of seconds that cannot be selected\n */\n disabledSeconds: {\n type: definePropType<GetDisabledSeconds>(Function),\n },\n} as const)\n\nexport type DisabledTimeListsProps = ExtractPropTypes<\n typeof disabledTimeListsProps\n>\nexport type DisabledTimeListsPropsPublic = __ExtractPublicPropTypes<\n typeof disabledTimeListsProps\n>\n\nexport const timePanelSharedProps = buildProps({\n visible: Boolean,\n actualVisible: {\n type: Boolean,\n default: undefined,\n },\n format: {\n type: String,\n default: '',\n },\n} as const)\n\nexport type TimePanelSharedProps = ExtractPropTypes<typeof timePanelSharedProps>\nexport type TimePanelSharedPropsPublic = __ExtractPublicPropTypes<\n typeof timePanelSharedProps\n>\n"],"names":["buildProps","definePropType"],"mappings":";;;;;;AACY,MAAC,sBAAsB,GAAGA,kBAAU,CAAC;AACjD,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAEC,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,EAAE,eAAe,EAAE;AACnB,IAAI,IAAI,EAAEA,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,EAAE,eAAe,EAAE;AACnB,IAAI,IAAI,EAAEA,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,CAAC,EAAE;AACS,MAAC,oBAAoB,GAAGD,kBAAU,CAAC;AAC/C,EAAE,OAAO,EAAE,OAAO;AAClB,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,MAAM,EAAE;AACV,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,CAAC;;;;;"}

327
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/basic-time-spinner.js generated vendored Normal file
View File

@@ -0,0 +1,327 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var lodashUnified = require('lodash-unified');
var index$1 = require('../../../scrollbar/index.js');
var index$2 = require('../../../icon/index.js');
var iconsVue = require('@element-plus/icons-vue');
var constants = require('../constants.js');
var utils = require('../utils.js');
var basicTimeSpinner = require('../props/basic-time-spinner.js');
var useTimePicker = require('../composables/use-time-picker.js');
var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
var index$3 = require('../../../../directives/repeat-click/index.js');
var event = require('../../../../constants/event.js');
var index = require('../../../../hooks/use-namespace/index.js');
var style = require('../../../../utils/dom/style.js');
var types = require('../../../../utils/types.js');
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
__name: "basic-time-spinner",
props: basicTimeSpinner.basicTimeSpinnerProps,
emits: [event.CHANGE_EVENT, "select-range", "set-option"],
setup(__props, { emit }) {
const props = __props;
const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
const { isRange, format } = pickerBase.props;
const ns = index.useNamespace("time");
const { getHoursList, getMinutesList, getSecondsList } = useTimePicker.getTimeLists(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
let isScrolling = false;
const currentScrollbar = vue.ref();
const listHoursRef = vue.ref();
const listMinutesRef = vue.ref();
const listSecondsRef = vue.ref();
const listRefsMap = {
hours: listHoursRef,
minutes: listMinutesRef,
seconds: listSecondsRef
};
const spinnerItems = vue.computed(() => {
return props.showSeconds ? constants.timeUnits : constants.timeUnits.slice(0, 2);
});
const timePartials = vue.computed(() => {
const { spinnerDate } = props;
const hours = spinnerDate.hour();
const minutes = spinnerDate.minute();
const seconds = spinnerDate.second();
return { hours, minutes, seconds };
});
const timeList = vue.computed(() => {
const { hours, minutes } = vue.unref(timePartials);
const { role, spinnerDate } = props;
const compare = !isRange ? spinnerDate : void 0;
return {
hours: getHoursList(role, compare),
minutes: getMinutesList(hours, role, compare),
seconds: getSecondsList(hours, minutes, role, compare)
};
});
const arrowControlTimeList = vue.computed(() => {
const { hours, minutes, seconds } = vue.unref(timePartials);
return {
hours: utils.buildTimeList(hours, 23),
minutes: utils.buildTimeList(minutes, 59),
seconds: utils.buildTimeList(seconds, 59)
};
});
const debouncedResetScroll = lodashUnified.debounce((type) => {
isScrolling = false;
adjustCurrentSpinner(type);
}, 200);
const getAmPmFlag = (hour) => {
const shouldShowAmPm = !!props.amPmMode;
if (!shouldShowAmPm)
return "";
const isCapital = props.amPmMode === "A";
let content = hour < 12 ? " am" : " pm";
if (isCapital)
content = content.toUpperCase();
return content;
};
const emitSelectRange = (type) => {
let range = [0, 0];
const actualFormat = format || constants.DEFAULT_FORMATS_TIME;
const hourIndex = actualFormat.indexOf("HH");
const minuteIndex = actualFormat.indexOf("mm");
const secondIndex = actualFormat.indexOf("ss");
switch (type) {
case "hours":
if (hourIndex !== -1) {
range = [hourIndex, hourIndex + 2];
}
break;
case "minutes":
if (minuteIndex !== -1) {
range = [minuteIndex, minuteIndex + 2];
}
break;
case "seconds":
if (secondIndex !== -1) {
range = [secondIndex, secondIndex + 2];
}
break;
}
const [left, right] = range;
emit("select-range", left, right);
currentScrollbar.value = type;
};
const adjustCurrentSpinner = (type) => {
adjustSpinner(type, vue.unref(timePartials)[type]);
};
const adjustSpinners = () => {
adjustCurrentSpinner("hours");
adjustCurrentSpinner("minutes");
adjustCurrentSpinner("seconds");
};
const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
const adjustSpinner = (type, value) => {
if (props.arrowControl)
return;
const scrollbar = vue.unref(listRefsMap[type]);
if (scrollbar && scrollbar.$el) {
getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type));
}
};
const typeItemHeight = (type) => {
const scrollbar = vue.unref(listRefsMap[type]);
const listItem = scrollbar == null ? void 0 : scrollbar.$el.querySelector("li");
if (listItem) {
return Number.parseFloat(style.getStyle(listItem, "height")) || 0;
}
return 0;
};
const onIncrement = () => {
scrollDown(1);
};
const onDecrement = () => {
scrollDown(-1);
};
const scrollDown = (step) => {
if (!currentScrollbar.value) {
emitSelectRange("hours");
}
const label = currentScrollbar.value;
const now = vue.unref(timePartials)[label];
const total = currentScrollbar.value === "hours" ? 24 : 60;
const next = findNextUnDisabled(label, now, step, total);
modifyDateField(label, next);
adjustSpinner(label, next);
vue.nextTick(() => emitSelectRange(label));
};
const findNextUnDisabled = (type, now, step, total) => {
let next = (now + step + total) % total;
const list = vue.unref(timeList)[type];
while (list[next] && next !== now) {
next = (next + step + total) % total;
}
return next;
};
const modifyDateField = (type, value) => {
const list = vue.unref(timeList)[type];
const isDisabled = list[value];
if (isDisabled)
return;
const { hours, minutes, seconds } = vue.unref(timePartials);
let changeTo;
switch (type) {
case "hours":
changeTo = props.spinnerDate.hour(value).minute(minutes).second(seconds);
break;
case "minutes":
changeTo = props.spinnerDate.hour(hours).minute(value).second(seconds);
break;
case "seconds":
changeTo = props.spinnerDate.hour(hours).minute(minutes).second(value);
break;
}
emit(event.CHANGE_EVENT, changeTo);
};
const handleClick = (type, { value, disabled }) => {
if (!disabled) {
modifyDateField(type, value);
emitSelectRange(type);
adjustSpinner(type, value);
}
};
const handleScroll = (type) => {
const scrollbar = vue.unref(listRefsMap[type]);
if (!scrollbar)
return;
isScrolling = true;
debouncedResetScroll(type);
const value = Math.min(Math.round((getScrollbarElement(scrollbar.$el).scrollTop - (scrollBarHeight(type) * 0.5 - 10) / typeItemHeight(type) + 3) / typeItemHeight(type)), type === "hours" ? 23 : 59);
modifyDateField(type, value);
};
const scrollBarHeight = (type) => {
return vue.unref(listRefsMap[type]).$el.offsetHeight;
};
const bindScrollEvent = () => {
const bindFunction = (type) => {
const scrollbar = vue.unref(listRefsMap[type]);
if (scrollbar && scrollbar.$el) {
getScrollbarElement(scrollbar.$el).onscroll = () => {
handleScroll(type);
};
}
};
bindFunction("hours");
bindFunction("minutes");
bindFunction("seconds");
};
vue.onMounted(() => {
vue.nextTick(() => {
!props.arrowControl && bindScrollEvent();
adjustSpinners();
if (props.role === "start")
emitSelectRange("hours");
});
});
const setRef = (scrollbar, type) => {
listRefsMap[type].value = scrollbar != null ? scrollbar : void 0;
};
emit("set-option", [`${props.role}_scrollDown`, scrollDown]);
emit("set-option", [`${props.role}_emitSelectRange`, emitSelectRange]);
vue.watch(() => props.spinnerDate, () => {
if (isScrolling)
return;
adjustSpinners();
});
return (_ctx, _cache) => {
return vue.openBlock(), vue.createElementBlock("div", {
class: vue.normalizeClass([vue.unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }])
}, [
!_ctx.arrowControl ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(vue.unref(spinnerItems), (item) => {
return vue.openBlock(), vue.createBlock(vue.unref(index$1.ElScrollbar), {
key: item,
ref_for: true,
ref: (scrollbar) => setRef(scrollbar, item),
class: vue.normalizeClass(vue.unref(ns).be("spinner", "wrapper")),
"wrap-style": "max-height: inherit;",
"view-class": vue.unref(ns).be("spinner", "list"),
noresize: "",
tag: "ul",
onMouseenter: ($event) => emitSelectRange(item),
onMousemove: ($event) => adjustCurrentSpinner(item)
}, {
default: vue.withCtx(() => [
(vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(timeList)[item], (disabled, key) => {
return vue.openBlock(), vue.createElementBlock("li", {
key,
class: vue.normalizeClass([
vue.unref(ns).be("spinner", "item"),
vue.unref(ns).is("active", key === vue.unref(timePartials)[item]),
vue.unref(ns).is("disabled", disabled)
]),
onClick: ($event) => handleClick(item, { value: key, disabled })
}, [
item === "hours" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
vue.createTextVNode(vue.toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + vue.toDisplayString(getAmPmFlag(key)), 1)
], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
vue.createTextVNode(vue.toDisplayString(("0" + key).slice(-2)), 1)
], 64))
], 10, ["onClick"]);
}), 128))
]),
_: 2
}, 1032, ["class", "view-class", "onMouseenter", "onMousemove"]);
}), 128)) : vue.createCommentVNode("v-if", true),
_ctx.arrowControl ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(vue.unref(spinnerItems), (item) => {
return vue.openBlock(), vue.createElementBlock("div", {
key: item,
class: vue.normalizeClass([vue.unref(ns).be("spinner", "wrapper"), vue.unref(ns).is("arrow")]),
onMouseenter: ($event) => emitSelectRange(item)
}, [
vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(index$2.ElIcon), {
class: vue.normalizeClass(["arrow-up", vue.unref(ns).be("spinner", "arrow")])
}, {
default: vue.withCtx(() => [
vue.createVNode(vue.unref(iconsVue.ArrowUp))
]),
_: 1
}, 8, ["class"])), [
[vue.unref(index$3.vRepeatClick), onDecrement]
]),
vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(index$2.ElIcon), {
class: vue.normalizeClass(["arrow-down", vue.unref(ns).be("spinner", "arrow")])
}, {
default: vue.withCtx(() => [
vue.createVNode(vue.unref(iconsVue.ArrowDown))
]),
_: 1
}, 8, ["class"])), [
[vue.unref(index$3.vRepeatClick), onIncrement]
]),
vue.createElementVNode("ul", {
class: vue.normalizeClass(vue.unref(ns).be("spinner", "list"))
}, [
(vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(arrowControlTimeList)[item], (time, key) => {
return vue.openBlock(), vue.createElementBlock("li", {
key,
class: vue.normalizeClass([
vue.unref(ns).be("spinner", "item"),
vue.unref(ns).is("active", time === vue.unref(timePartials)[item]),
vue.unref(ns).is("disabled", vue.unref(timeList)[item][time])
])
}, [
vue.unref(types.isNumber)(time) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
item === "hours" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
vue.createTextVNode(vue.toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + vue.toDisplayString(getAmPmFlag(time)), 1)
], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
vue.createTextVNode(vue.toDisplayString(("0" + time).slice(-2)), 1)
], 64))
], 64)) : vue.createCommentVNode("v-if", true)
], 2);
}), 128))
], 2)
], 42, ["onMouseenter"]);
}), 128)) : vue.createCommentVNode("v-if", true)
], 2);
};
}
});
var TimeSpinner = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "basic-time-spinner.vue"]]);
exports["default"] = TimeSpinner;
//# sourceMappingURL=basic-time-spinner.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/basic-time-spinner.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

82
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/basic-time-spinner.vue.d.ts generated vendored Normal file
View File

@@ -0,0 +1,82 @@
declare const _default: import("vue").DefineComponent<{
readonly disabledHours: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly role: {
readonly type: import("vue").PropType<string>;
readonly required: true;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly spinnerDate: {
readonly type: import("vue").PropType<import("dayjs").Dayjs>;
readonly required: true;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly showSeconds: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly arrowControl: BooleanConstructor;
readonly amPmMode: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | ((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A"))[], unknown, unknown, "", boolean>;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
change: (...args: any[]) => void;
"select-range": (...args: any[]) => void;
"set-option": (...args: any[]) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly disabledHours: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledMinutes: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly disabledSeconds: {
readonly type: import("vue").PropType<import("element-plus").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly role: {
readonly type: import("vue").PropType<string>;
readonly required: true;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly spinnerDate: {
readonly type: import("vue").PropType<import("dayjs").Dayjs>;
readonly required: true;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly showSeconds: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
readonly arrowControl: BooleanConstructor;
readonly amPmMode: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | ((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A"))[], unknown, unknown, "", boolean>;
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onSelect-range"?: ((...args: any[]) => any) | undefined;
"onSet-option"?: ((...args: any[]) => any) | undefined;
}, {
readonly arrowControl: boolean;
readonly showSeconds: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
readonly amPmMode: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | ((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A"))[], unknown, unknown>;
}>;
export default _default;

192
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-pick.js generated vendored Normal file
View File

@@ -0,0 +1,192 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var dayjs = require('dayjs');
var constants = require('../constants.js');
var panelTimePicker = require('../props/panel-time-picker.js');
var useTimePanel = require('../composables/use-time-panel.js');
var useTimePicker = require('../composables/use-time-picker.js');
var basicTimeSpinner = require('./basic-time-spinner.js');
var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../../hooks/use-namespace/index.js');
var index$1 = require('../../../../hooks/use-locale/index.js');
var types = require('../../../../utils/types.js');
var event = require('../../../../utils/dom/event.js');
var aria = require('../../../../constants/aria.js');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
__name: "panel-time-pick",
props: panelTimePicker.panelTimePickerProps,
emits: ["pick", "select-range", "set-picker-option"],
setup(__props, { emit }) {
const props = __props;
const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
const {
arrowControl,
disabledHours,
disabledMinutes,
disabledSeconds,
defaultValue
} = pickerBase.props;
const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = useTimePicker.buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
const ns = index.useNamespace("time");
const { t, lang } = index$1.useLocale();
const selectionRange = vue.ref([0, 2]);
const oldValue = useTimePicker.useOldValue(props);
const transitionName = vue.computed(() => {
return types.isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
});
const showSeconds = vue.computed(() => {
return props.format.includes("ss");
});
const amPmMode = vue.computed(() => {
if (props.format.includes("A"))
return "A";
if (props.format.includes("a"))
return "a";
return "";
});
const isValidValue = (_date) => {
const parsedDate = dayjs__default["default"](_date).locale(lang.value);
const result = getRangeAvailableTime(parsedDate);
return parsedDate.isSame(result);
};
const handleCancel = () => {
const old = oldValue.value;
emit("pick", old, false);
vue.nextTick(() => {
oldValue.value = old;
});
};
const handleConfirm = (visible = false, first = false) => {
if (first)
return;
emit("pick", props.parsedValue, visible);
};
const handleChange = (_date) => {
if (!props.visible) {
return;
}
const result = getRangeAvailableTime(_date).millisecond(0);
emit("pick", result, true);
};
const setSelectionRange = (start, end) => {
emit("select-range", start, end);
selectionRange.value = [start, end];
};
const changeSelectionRange = (step) => {
const actualFormat = props.format;
const hourIndex = actualFormat.indexOf("HH");
const minuteIndex = actualFormat.indexOf("mm");
const secondIndex = actualFormat.indexOf("ss");
const list = [];
const mapping = [];
if (hourIndex !== -1) {
list.push(hourIndex);
mapping.push("hours");
}
if (minuteIndex !== -1) {
list.push(minuteIndex);
mapping.push("minutes");
}
if (secondIndex !== -1 && showSeconds.value) {
list.push(secondIndex);
mapping.push("seconds");
}
const index = list.indexOf(selectionRange.value[0]);
const next = (index + step + list.length) % list.length;
timePickerOptions["start_emitSelectRange"](mapping[next]);
};
const handleKeydown = (event$1) => {
const code = event.getEventCode(event$1);
const { left, right, up, down } = aria.EVENT_CODE;
if ([left, right].includes(code)) {
const step = code === left ? -1 : 1;
changeSelectionRange(step);
event$1.preventDefault();
return;
}
if ([up, down].includes(code)) {
const step = code === up ? -1 : 1;
timePickerOptions["start_scrollDown"](step);
event$1.preventDefault();
return;
}
};
const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel.useTimePanel({
getAvailableHours,
getAvailableMinutes,
getAvailableSeconds
});
const getRangeAvailableTime = (date) => {
return getAvailableTime(date, props.datetimeRole || "", true);
};
const parseUserInput = (value) => {
if (!value)
return null;
return dayjs__default["default"](value, props.format).locale(lang.value);
};
const getDefaultValue = () => {
return dayjs__default["default"](defaultValue).locale(lang.value);
};
emit("set-picker-option", ["isValidValue", isValidValue]);
emit("set-picker-option", ["parseUserInput", parseUserInput]);
emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
return (_ctx, _cache) => {
return vue.openBlock(), vue.createBlock(vue.Transition, { name: vue.unref(transitionName) }, {
default: vue.withCtx(() => [
_ctx.actualVisible || _ctx.visible ? (vue.openBlock(), vue.createElementBlock("div", {
key: 0,
class: vue.normalizeClass(vue.unref(ns).b("panel"))
}, [
vue.createElementVNode("div", {
class: vue.normalizeClass([vue.unref(ns).be("panel", "content"), { "has-seconds": vue.unref(showSeconds) }])
}, [
vue.createVNode(basicTimeSpinner["default"], {
ref: "spinner",
role: _ctx.datetimeRole || "start",
"arrow-control": vue.unref(arrowControl),
"show-seconds": vue.unref(showSeconds),
"am-pm-mode": vue.unref(amPmMode),
"spinner-date": _ctx.parsedValue,
"disabled-hours": vue.unref(disabledHours),
"disabled-minutes": vue.unref(disabledMinutes),
"disabled-seconds": vue.unref(disabledSeconds),
onChange: handleChange,
onSetOption: vue.unref(onSetOption),
onSelectRange: setSelectionRange
}, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onSetOption"])
], 2),
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(ns).be("panel", "footer"))
}, [
vue.createElementVNode("button", {
type: "button",
class: vue.normalizeClass([vue.unref(ns).be("panel", "btn"), "cancel"]),
onClick: handleCancel
}, vue.toDisplayString(vue.unref(t)("el.datepicker.cancel")), 3),
vue.createElementVNode("button", {
type: "button",
class: vue.normalizeClass([vue.unref(ns).be("panel", "btn"), "confirm"]),
onClick: ($event) => handleConfirm()
}, vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 11, ["onClick"])
], 2)
], 2)) : vue.createCommentVNode("v-if", true)
]),
_: 1
}, 8, ["name"]);
};
}
});
var TimePickPanel = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "panel-time-pick.vue"]]);
exports["default"] = TimePickPanel;
//# sourceMappingURL=panel-time-pick.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-pick.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

37
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-pick.vue.d.ts generated vendored Normal file
View File

@@ -0,0 +1,37 @@
import dayjs from 'dayjs';
declare const _default: import("vue").DefineComponent<{
readonly datetimeRole: StringConstructor;
readonly parsedValue: {
readonly type: import("vue").PropType<dayjs.Dayjs>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"select-range": (...args: any[]) => void;
pick: (...args: any[]) => void;
"set-picker-option": (...args: any[]) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly datetimeRole: StringConstructor;
readonly parsedValue: {
readonly type: import("vue").PropType<dayjs.Dayjs>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
}>> & {
onPick?: ((...args: any[]) => any) | undefined;
"onSelect-range"?: ((...args: any[]) => any) | undefined;
"onSet-picker-option"?: ((...args: any[]) => any) | undefined;
}, {
readonly visible: boolean;
readonly format: string;
readonly actualVisible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
}>;
export default _default;

293
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-range.js generated vendored Normal file
View File

@@ -0,0 +1,293 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var dayjs = require('dayjs');
var lodashUnified = require('lodash-unified');
var constants = require('../constants.js');
var panelTimeRange = require('../props/panel-time-range.js');
var useTimePanel = require('../composables/use-time-panel.js');
var useTimePicker = require('../composables/use-time-picker.js');
var basicTimeSpinner = require('./basic-time-spinner.js');
var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../../hooks/use-locale/index.js');
var index$1 = require('../../../../hooks/use-namespace/index.js');
var event = require('../../../../utils/dom/event.js');
var shared = require('@vue/shared');
var aria = require('../../../../constants/aria.js');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
__name: "panel-time-range",
props: panelTimeRange.panelTimeRangeProps,
emits: ["pick", "select-range", "set-picker-option"],
setup(__props, { emit }) {
const props = __props;
const makeSelectRange = (start, end) => {
const result = [];
for (let i = start; i <= end; i++) {
result.push(i);
}
return result;
};
const { t, lang } = index.useLocale();
const nsTime = index$1.useNamespace("time");
const nsPicker = index$1.useNamespace("picker");
const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
const {
arrowControl,
disabledHours,
disabledMinutes,
disabledSeconds,
defaultValue
} = pickerBase.props;
const startContainerKls = vue.computed(() => [
nsTime.be("range-picker", "body"),
nsTime.be("panel", "content"),
nsTime.is("arrow", arrowControl),
showSeconds.value ? "has-seconds" : ""
]);
const endContainerKls = vue.computed(() => [
nsTime.be("range-picker", "body"),
nsTime.be("panel", "content"),
nsTime.is("arrow", arrowControl),
showSeconds.value ? "has-seconds" : ""
]);
const startTime = vue.computed(() => props.parsedValue[0]);
const endTime = vue.computed(() => props.parsedValue[1]);
const oldValue = useTimePicker.useOldValue(props);
const handleCancel = () => {
const old = oldValue.value;
emit("pick", old, false);
vue.nextTick(() => {
oldValue.value = old;
});
};
const showSeconds = vue.computed(() => {
return props.format.includes("ss");
});
const amPmMode = vue.computed(() => {
if (props.format.includes("A"))
return "A";
if (props.format.includes("a"))
return "a";
return "";
});
const handleConfirm = (visible = false) => {
emit("pick", [startTime.value, endTime.value], visible);
};
const handleMinChange = (date) => {
handleChange(date.millisecond(0), endTime.value);
};
const handleMaxChange = (date) => {
handleChange(startTime.value, date.millisecond(0));
};
const isValidValue = (_date) => {
const parsedDate = _date.map((_) => dayjs__default["default"](_).locale(lang.value));
const result = getRangeAvailableTime(parsedDate);
return parsedDate[0].isSame(result[0]) && parsedDate[1].isSame(result[1]);
};
const handleChange = (start, end) => {
if (!props.visible) {
return;
}
emit("pick", [start, end], true);
};
const btnConfirmDisabled = vue.computed(() => {
return startTime.value > endTime.value;
});
const selectionRange = vue.ref([0, 2]);
const setMinSelectionRange = (start, end) => {
emit("select-range", start, end, "min");
selectionRange.value = [start, end];
};
const offset = vue.computed(() => showSeconds.value ? 11 : 8);
const setMaxSelectionRange = (start, end) => {
emit("select-range", start, end, "max");
const _offset = vue.unref(offset);
selectionRange.value = [start + _offset, end + _offset];
};
const changeSelectionRange = (step) => {
const list = showSeconds.value ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
const index = list.indexOf(selectionRange.value[0]);
const next = (index + step + list.length) % list.length;
const half = list.length / 2;
if (next < half) {
timePickerOptions["start_emitSelectRange"](mapping[next]);
} else {
timePickerOptions["end_emitSelectRange"](mapping[next - half]);
}
};
const handleKeydown = (event$1) => {
const code = event.getEventCode(event$1);
const { left, right, up, down } = aria.EVENT_CODE;
if ([left, right].includes(code)) {
const step = code === left ? -1 : 1;
changeSelectionRange(step);
event$1.preventDefault();
return;
}
if ([up, down].includes(code)) {
const step = code === up ? -1 : 1;
const role = selectionRange.value[0] < offset.value ? "start" : "end";
timePickerOptions[`${role}_scrollDown`](step);
event$1.preventDefault();
return;
}
};
const disabledHours_ = (role, compare) => {
const defaultDisable = disabledHours ? disabledHours(role) : [];
const isStart = role === "start";
const compareDate = compare || (isStart ? endTime.value : startTime.value);
const compareHour = compareDate.hour();
const nextDisable = isStart ? makeSelectRange(compareHour + 1, 23) : makeSelectRange(0, compareHour - 1);
return lodashUnified.union(defaultDisable, nextDisable);
};
const disabledMinutes_ = (hour, role, compare) => {
const defaultDisable = disabledMinutes ? disabledMinutes(hour, role) : [];
const isStart = role === "start";
const compareDate = compare || (isStart ? endTime.value : startTime.value);
const compareHour = compareDate.hour();
if (hour !== compareHour) {
return defaultDisable;
}
const compareMinute = compareDate.minute();
const nextDisable = isStart ? makeSelectRange(compareMinute + 1, 59) : makeSelectRange(0, compareMinute - 1);
return lodashUnified.union(defaultDisable, nextDisable);
};
const disabledSeconds_ = (hour, minute, role, compare) => {
const defaultDisable = disabledSeconds ? disabledSeconds(hour, minute, role) : [];
const isStart = role === "start";
const compareDate = compare || (isStart ? endTime.value : startTime.value);
const compareHour = compareDate.hour();
const compareMinute = compareDate.minute();
if (hour !== compareHour || minute !== compareMinute) {
return defaultDisable;
}
const compareSecond = compareDate.second();
const nextDisable = isStart ? makeSelectRange(compareSecond + 1, 59) : makeSelectRange(0, compareSecond - 1);
return lodashUnified.union(defaultDisable, nextDisable);
};
const getRangeAvailableTime = ([start, end]) => {
return [
getAvailableTime(start, "start", true, end),
getAvailableTime(end, "end", false, start)
];
};
const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = useTimePicker.buildAvailableTimeSlotGetter(disabledHours_, disabledMinutes_, disabledSeconds_);
const {
timePickerOptions,
getAvailableTime,
onSetOption
} = useTimePanel.useTimePanel({
getAvailableHours,
getAvailableMinutes,
getAvailableSeconds
});
const parseUserInput = (days) => {
if (!days)
return null;
if (shared.isArray(days)) {
return days.map((d) => dayjs__default["default"](d, props.format).locale(lang.value));
}
return dayjs__default["default"](days, props.format).locale(lang.value);
};
const getDefaultValue = () => {
if (shared.isArray(defaultValue)) {
return defaultValue.map((d) => dayjs__default["default"](d).locale(lang.value));
}
const defaultDay = dayjs__default["default"](defaultValue).locale(lang.value);
return [defaultDay, defaultDay.add(60, "m")];
};
emit("set-picker-option", ["parseUserInput", parseUserInput]);
emit("set-picker-option", ["isValidValue", isValidValue]);
emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
return (_ctx, _cache) => {
return _ctx.actualVisible ? (vue.openBlock(), vue.createElementBlock("div", {
key: 0,
class: vue.normalizeClass([vue.unref(nsTime).b("range-picker"), vue.unref(nsPicker).b("panel")])
}, [
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "content"))
}, [
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "cell"))
}, [
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "header"))
}, vue.toDisplayString(vue.unref(t)("el.datepicker.startTime")), 3),
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(startContainerKls))
}, [
vue.createVNode(basicTimeSpinner["default"], {
ref: "minSpinner",
role: "start",
"show-seconds": vue.unref(showSeconds),
"am-pm-mode": vue.unref(amPmMode),
"arrow-control": vue.unref(arrowControl),
"spinner-date": vue.unref(startTime),
"disabled-hours": disabledHours_,
"disabled-minutes": disabledMinutes_,
"disabled-seconds": disabledSeconds_,
onChange: handleMinChange,
onSetOption: vue.unref(onSetOption),
onSelectRange: setMinSelectionRange
}, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
], 2)
], 2),
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "cell"))
}, [
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "header"))
}, vue.toDisplayString(vue.unref(t)("el.datepicker.endTime")), 3),
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(endContainerKls))
}, [
vue.createVNode(basicTimeSpinner["default"], {
ref: "maxSpinner",
role: "end",
"show-seconds": vue.unref(showSeconds),
"am-pm-mode": vue.unref(amPmMode),
"arrow-control": vue.unref(arrowControl),
"spinner-date": vue.unref(endTime),
"disabled-hours": disabledHours_,
"disabled-minutes": disabledMinutes_,
"disabled-seconds": disabledSeconds_,
onChange: handleMaxChange,
onSetOption: vue.unref(onSetOption),
onSelectRange: setMaxSelectionRange
}, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
], 2)
], 2)
], 2),
vue.createElementVNode("div", {
class: vue.normalizeClass(vue.unref(nsTime).be("panel", "footer"))
}, [
vue.createElementVNode("button", {
type: "button",
class: vue.normalizeClass([vue.unref(nsTime).be("panel", "btn"), "cancel"]),
onClick: ($event) => handleCancel()
}, vue.toDisplayString(vue.unref(t)("el.datepicker.cancel")), 11, ["onClick"]),
vue.createElementVNode("button", {
type: "button",
class: vue.normalizeClass([vue.unref(nsTime).be("panel", "btn"), "confirm"]),
disabled: vue.unref(btnConfirmDisabled),
onClick: ($event) => handleConfirm()
}, vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 11, ["disabled", "onClick"])
], 2)
], 2)) : vue.createCommentVNode("v-if", true);
};
}
});
var TimeRangePanel = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "panel-time-range.vue"]]);
exports["default"] = TimeRangePanel;
//# sourceMappingURL=panel-time-range.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-range.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

35
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-range.vue.d.ts generated vendored Normal file
View File

@@ -0,0 +1,35 @@
import dayjs from 'dayjs';
declare const _default: import("vue").DefineComponent<{
readonly parsedValue: {
readonly type: import("vue").PropType<[dayjs.Dayjs, dayjs.Dayjs]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
"select-range": (...args: any[]) => void;
pick: (...args: any[]) => void;
"set-picker-option": (...args: any[]) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly parsedValue: {
readonly type: import("vue").PropType<[dayjs.Dayjs, dayjs.Dayjs]>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly visible: BooleanConstructor;
readonly actualVisible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
}>> & {
onPick?: ((...args: any[]) => any) | undefined;
"onSelect-range"?: ((...args: any[]) => any) | undefined;
"onSet-picker-option"?: ((...args: any[]) => any) | undefined;
}, {
readonly visible: boolean;
readonly format: string;
readonly actualVisible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
}>;
export default _default;

449
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker.d.ts generated vendored Normal file
View File

@@ -0,0 +1,449 @@
declare const _default: import("vue").DefineComponent<{
/**
* @description whether to pick a time range
*/
isRange: BooleanConstructor;
showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
showConfirm: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
showWeekNumber: BooleanConstructor;
ariaLabel: StringConstructor;
emptyValues: ArrayConstructor;
valueOnClear: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown, undefined, boolean>;
disabledDate: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
cellClassName: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
arrowControl: BooleanConstructor;
tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
unlinkPanels: BooleanConstructor;
placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement))[], import("element-plus").Placement, unknown, "bottom", boolean>;
fallbackPlacements: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | ((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]))[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
disabledHours: {
readonly type: import("vue").PropType<import("./common/props").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
disabledMinutes: {
readonly type: import("vue").PropType<import("./common/props").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
disabledSeconds: {
readonly type: import("vue").PropType<import("./common/props").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
automaticDropdown: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
id: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
name: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
popperClass: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
popperStyle: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
format: StringConstructor;
valueFormat: StringConstructor;
dateFormat: StringConstructor;
timeFormat: StringConstructor;
type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
clearIcon: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
editable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
prefixIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown, "", boolean>;
size: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly: BooleanConstructor;
disabled: BooleanConstructor;
placeholder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | ((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>))[], unknown, unknown, () => {}, boolean>;
modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./common/props").ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./common/props").ModelValueType | null))[], unknown, unknown, "", boolean>;
rangeSeparator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
startPlaceholder: StringConstructor;
endPlaceholder: StringConstructor;
defaultValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
defaultTime: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
/**
* @description whether to pick a time range
*/
isRange: BooleanConstructor;
showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
showConfirm: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
showWeekNumber: BooleanConstructor;
ariaLabel: StringConstructor;
emptyValues: ArrayConstructor;
valueOnClear: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown, undefined, boolean>;
disabledDate: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
cellClassName: {
readonly type: import("vue").PropType<Function>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
arrowControl: BooleanConstructor;
tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
unlinkPanels: BooleanConstructor;
placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement))[], import("element-plus").Placement, unknown, "bottom", boolean>;
fallbackPlacements: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | ((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]))[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
disabledHours: {
readonly type: import("vue").PropType<import("./common/props").GetDisabledHours>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
disabledMinutes: {
readonly type: import("vue").PropType<import("./common/props").GetDisabledMinutes>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
disabledSeconds: {
readonly type: import("vue").PropType<import("./common/props").GetDisabledSeconds>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
automaticDropdown: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
id: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
name: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>) | ((new (...args: any[]) => string | [string, string]) | (() => import("./common/props").SingleOrRange<string>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
popperClass: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | (string | {
[x: string]: boolean;
} | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
popperStyle: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
format: StringConstructor;
valueFormat: StringConstructor;
dateFormat: StringConstructor;
timeFormat: StringConstructor;
type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
clearIcon: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
editable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
prefixIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown, "", boolean>;
size: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
readonly: BooleanConstructor;
disabled: BooleanConstructor;
placeholder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | ((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>))[], unknown, unknown, () => {}, boolean>;
modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./common/props").ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./common/props").ModelValueType | null))[], unknown, unknown, "", boolean>;
rangeSeparator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
startPlaceholder: StringConstructor;
endPlaceholder: StringConstructor;
defaultValue: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
defaultTime: {
readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("./common/props").SingleOrRange<Date>))[], unknown, unknown>>;
readonly required: false;
readonly validator: ((val: unknown) => boolean) | undefined;
__epPropKey: true;
};
}>> & {
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
disabled: boolean;
tabindex: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>;
type: string;
placeholder: string;
modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./common/props").ModelValueType | null) | ((new (...args: any[]) => string | number | Date | string[] | number[] | Date[]) | (() => import("./common/props").ModelValueType | null))[], unknown, unknown>;
placement: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | ((new (...args: any[]) => "left" | "right" | "top" | "bottom" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement))[], import("element-plus").Placement, unknown>;
valueOnClear: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | ((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null))[], unknown, unknown>;
readonly: boolean;
prefixIcon: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>;
validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
fallbackPlacements: import("element-plus").Placement[];
popperOptions: Partial<import("element-plus").Options>;
automaticDropdown: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
editable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
rangeSeparator: string;
shortcuts: unknown[];
showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
showConfirm: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
showWeekNumber: boolean;
arrowControl: boolean;
unlinkPanels: boolean;
isRange: boolean;
}>;
export default _default;

68
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker.js generated vendored Normal file
View File

@@ -0,0 +1,68 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var vue = require('vue');
var dayjs = require('dayjs');
var customParseFormat = require('dayjs/plugin/customParseFormat.js');
var constants = require('./constants.js');
var picker = require('./common/picker.js');
var panelTimePick = require('./time-picker-com/panel-time-pick.js');
var panelTimeRange = require('./time-picker-com/panel-time-range.js');
var props = require('./common/props.js');
var event = require('../../../constants/event.js');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
var customParseFormat__default = /*#__PURE__*/_interopDefaultLegacy(customParseFormat);
dayjs__default["default"].extend(customParseFormat__default["default"]);
var TimePicker = vue.defineComponent({
name: "ElTimePicker",
install: null,
props: {
...props.timePickerDefaultProps,
isRange: Boolean
},
emits: [event.UPDATE_MODEL_EVENT],
setup(props, ctx) {
const commonPicker = vue.ref();
const [type, Panel] = props.isRange ? ["timerange", panelTimeRange["default"]] : ["time", panelTimePick["default"]];
const modelUpdater = (value) => ctx.emit(event.UPDATE_MODEL_EVENT, value);
vue.provide(constants.PICKER_POPPER_OPTIONS_INJECTION_KEY, props.popperOptions);
ctx.expose({
focus: () => {
var _a;
(_a = commonPicker.value) == null ? void 0 : _a.focus();
},
blur: () => {
var _a;
(_a = commonPicker.value) == null ? void 0 : _a.blur();
},
handleOpen: () => {
var _a;
(_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
},
handleClose: () => {
var _a;
(_a = commonPicker.value) == null ? void 0 : _a.handleClose();
}
});
return () => {
var _a;
const format = (_a = props.format) != null ? _a : constants.DEFAULT_FORMATS_TIME;
return vue.createVNode(picker["default"], vue.mergeProps(props, {
"ref": commonPicker,
"type": type,
"format": format,
"onUpdate:modelValue": modelUpdater
}), {
default: (props2) => vue.createVNode(Panel, props2, null)
});
};
}
});
exports["default"] = TimePicker;
//# sourceMappingURL=time-picker.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/time-picker.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"time-picker.js","sources":["../../../../../../packages/components/time-picker/src/time-picker.tsx"],"sourcesContent":["import { defineComponent, provide, ref } from 'vue'\nimport dayjs from 'dayjs'\nimport customParseFormat from 'dayjs/plugin/customParseFormat.js'\nimport { UPDATE_MODEL_EVENT } from '@element-plus/constants'\nimport {\n DEFAULT_FORMATS_TIME,\n PICKER_POPPER_OPTIONS_INJECTION_KEY,\n} from './constants'\nimport Picker from './common/picker.vue'\nimport TimePickPanel from './time-picker-com/panel-time-pick.vue'\nimport TimeRangePanel from './time-picker-com/panel-time-range.vue'\nimport { timePickerDefaultProps } from './common/props'\n\ndayjs.extend(customParseFormat)\n\nexport default defineComponent({\n name: 'ElTimePicker',\n install: null,\n props: {\n ...timePickerDefaultProps,\n /**\n * @description whether to pick a time range\n */\n isRange: Boolean,\n },\n emits: [UPDATE_MODEL_EVENT],\n setup(props, ctx) {\n const commonPicker = ref<InstanceType<typeof Picker>>()\n const [type, Panel] = props.isRange\n ? ['timerange', TimeRangePanel]\n : ['time', TimePickPanel]\n\n const modelUpdater = (value: any) => ctx.emit(UPDATE_MODEL_EVENT, value)\n provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, props.popperOptions)\n ctx.expose({\n /**\n * @description focus the Input component\n */\n focus: () => {\n commonPicker.value?.focus()\n },\n /**\n * @description blur the Input component\n */\n blur: () => {\n commonPicker.value?.blur()\n },\n /**\n * @description open the TimePicker popper\n */\n handleOpen: () => {\n commonPicker.value?.handleOpen()\n },\n /**\n * @description close the TimePicker popper\n */\n handleClose: () => {\n commonPicker.value?.handleClose()\n },\n })\n\n return () => {\n const format = props.format ?? DEFAULT_FORMATS_TIME\n\n return (\n <Picker\n {...props}\n ref={commonPicker}\n type={type}\n format={format}\n onUpdate:modelValue={modelUpdater}\n >\n {{\n default: (props: any) => <Panel {...props} />,\n }}\n </Picker>\n )\n }\n },\n})\n"],"names":["dayjs","extend","customParseFormat","defineComponent","name","install","props","UPDATE_MODEL_EVENT","isRange","Boolean","ref","TimeRangePanel","TimePickPanel","setup","commonPicker","type","modelUpdater","value","ctx","emit","provide","PICKER_POPPER_OPTIONS_INJECTION_KEY","expose","focus","blur","_createVNode","Picker","_mergeProps","handleOpen","handleClose"],"mappings":";;;;;;;;;;;;;;;;;;;AAaAA,yBAAK,CAACC,MAAN,CAAaC,qCAAb,CAAA,CAAA;AAEA,iBAAeC,mBAAe,CAAC;AAC7BC,EAAAA,IAAI,EAAE,cADuB;AAE7BC,EAAAA,OAAO,EAAE,IAFoB;EAG7BC,KAAK,EAAE;;AAEL,IAAA,OAAA,EAAA,OAAA;AACJ,GAAA;AACA,EAAA,KAAA,EAAA,CAAAC,wBAAA,CAAA;AACIC,EAAAA,KAAAA,CAAAA,KAASC,EAAAA,GAAAA,EAAAA;IARkB,MAAA,YAAA,GAAAC,OAAA,EAAA,CAAA;IAUxB,MAAGH,CAAAA,IAAAA,EAAAA,KAAAA,CAAAA,GAAAA,KAVqB,CAAA,OAAA,GAAA,CAAA,WAAA,EAAAI,yBAAA,CAAA,GAAA,CAAA,MAAA,EAAAC,wBAAA,CAAA,CAAA;;AAW7BC,IAAAA,WAAMP,CAAAA,6CAAY,EAAA,KAAA,CAAA,aAAA,CAAA,CAAA;IAChB,GAAMQ,CAAAA,MAAAA,CAAAA;AACN,MAAA,KAAOC,EAAD;;QAIAC,CAAAA,EAAAA,GAAAA,YAAgBC,CAAAA,KAAeC,KAAG,IAACC,GAAKZ,KAAAA,CAAAA,GAAAA,EAAAA,CAAAA,KAAT,EAA6BU,CAAAA;;AAClEG,MAAAA,IAAAA,EAAQC,MAAD;QACHC,MAAJ,CAAW;AACT,QAAA,CAAA,EAAA,GAAA,YAAA,CAAA,KAAA,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,EAAA,CAAA;AACN,OAAA;AACA,MAAA,UAAA,EAAA,MAAA;AACMC,QAAAA,MAAa,CAAA;QACXT,CAAY,EAAA,GAAA,YAAZ,CAAA,KAAA,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,UAAA,EAAA,CAAA;OALO;;AAOT,QAAA,IAAA,EAAA,CAAA;AACN,QAAA,CAAA,EAAA,GAAA,YAAA,CAAA,KAAA,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,WAAA,EAAA,CAAA;AACA,OAAA;AACMU,KAAAA,CAAAA,CAAAA;WACc,MAAA;MACb,IAZQ,EAAA,CAAA;;AAaT,MAAA,OAAAC,eAAA,CAAAC,iBAAA,EAAAC,cAAA,CAAA,KAAA,EAAA;AACN,QAAA,KAAA,EAAA,YAAA;AACA,QAAA,MAAA,EAAA,IAAA;AACMC,QAAAA,QAAU,EAAE,MAAM;QAChBd,qBAAA,EAAA,YAAA;OAjBO,CAAA,EAAA;;AAmBT,OAAA,CAAA,CAAA;AACN,KAAA,CAAA;AACA,GAAA;AACMe,CAAAA,CAAAA;;;;"}

14
frontend/node_modules/element-plus/lib/components/time-picker/src/utils.d.ts generated vendored Normal file
View File

@@ -0,0 +1,14 @@
import dayjs from 'dayjs';
import type { Dayjs } from 'dayjs';
import type { DateOrDates, DayOrDays } from './common/props';
export type TimeList = [number | undefined, number, undefined | number];
export declare const buildTimeList: (value: number, bound: number) => TimeList;
export declare const rangeArr: (n: number) => number[];
export declare const extractDateFormat: (format: string) => string;
export declare const extractTimeFormat: (format: string) => string;
export declare const dateEquals: (a: Date | unknown, b: Date | unknown) => boolean;
export declare const valueEquals: (a: Array<Date> | unknown, b: Array<Date> | unknown) => boolean;
export declare const parseDate: (date: string | number | Date, format: string | undefined, lang: string) => dayjs.Dayjs | undefined;
export declare const formatter: (date: string | number | Date | Dayjs, format: string | undefined, lang: string) => string | number | Date | dayjs.Dayjs;
export declare const makeList: (total: number, method?: () => number[]) => boolean[];
export declare const dayOrDaysToDate: (dayOrDays: DayOrDays) => DateOrDates;

86
frontend/node_modules/element-plus/lib/components/time-picker/src/utils.js generated vendored Normal file
View File

@@ -0,0 +1,86 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var dayjs = require('dayjs');
var types = require('../../../utils/types.js');
var shared = require('@vue/shared');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
const buildTimeList = (value, bound) => {
return [
value > 0 ? value - 1 : void 0,
value,
value < bound ? value + 1 : void 0
];
};
const rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
const extractDateFormat = (format) => {
return format.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
};
const extractTimeFormat = (format) => {
return format.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
};
const dateEquals = function(a, b) {
const aIsDate = shared.isDate(a);
const bIsDate = shared.isDate(b);
if (aIsDate && bIsDate) {
return a.getTime() === b.getTime();
}
if (!aIsDate && !bIsDate) {
return a === b;
}
return false;
};
const valueEquals = function(a, b) {
const aIsArray = shared.isArray(a);
const bIsArray = shared.isArray(b);
if (aIsArray && bIsArray) {
if (a.length !== b.length) {
return false;
}
return a.every((item, index) => dateEquals(item, b[index]));
}
if (!aIsArray && !bIsArray) {
return dateEquals(a, b);
}
return false;
};
const parseDate = function(date, format, lang) {
const day = types.isEmpty(format) || format === "x" ? dayjs__default["default"](date).locale(lang) : dayjs__default["default"](date, format).locale(lang);
return day.isValid() ? day : void 0;
};
const formatter = function(date, format, lang) {
if (types.isEmpty(format))
return date;
if (format === "x")
return +date;
return dayjs__default["default"](date).locale(lang).format(format);
};
const makeList = (total, method) => {
var _a;
const arr = [];
const disabledArr = method == null ? void 0 : method();
for (let i = 0; i < total; i++) {
arr.push((_a = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a : false);
}
return arr;
};
const dayOrDaysToDate = (dayOrDays) => {
return shared.isArray(dayOrDays) ? dayOrDays.map((d) => d.toDate()) : dayOrDays.toDate();
};
exports.buildTimeList = buildTimeList;
exports.dateEquals = dateEquals;
exports.dayOrDaysToDate = dayOrDaysToDate;
exports.extractDateFormat = extractDateFormat;
exports.extractTimeFormat = extractTimeFormat;
exports.formatter = formatter;
exports.makeList = makeList;
exports.parseDate = parseDate;
exports.rangeArr = rangeArr;
exports.valueEquals = valueEquals;
//# sourceMappingURL=utils.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/src/utils.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

5
frontend/node_modules/element-plus/lib/components/time-picker/style/css.d.ts generated vendored Normal file
View File

@@ -0,0 +1,5 @@
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-time-picker.css';
import 'element-plus/es/components/input/style/css';
import 'element-plus/es/components/scrollbar/style/css';
import 'element-plus/es/components/popper/style/css';

9
frontend/node_modules/element-plus/lib/components/time-picker/style/css.js generated vendored Normal file
View File

@@ -0,0 +1,9 @@
'use strict';
require('../../base/style/css.js');
require('element-plus/theme-chalk/el-time-picker.css');
require('../../input/style/css.js');
require('../../scrollbar/style/css.js');
require('../../popper/style/css.js');
//# sourceMappingURL=css.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/style/css.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

5
frontend/node_modules/element-plus/lib/components/time-picker/style/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,5 @@
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/time-picker.scss';
import 'element-plus/es/components/input/style';
import 'element-plus/es/components/scrollbar/style';
import 'element-plus/es/components/popper/style';

9
frontend/node_modules/element-plus/lib/components/time-picker/style/index.js generated vendored Normal file
View File

@@ -0,0 +1,9 @@
'use strict';
require('../../base/style/index.js');
require('element-plus/theme-chalk/src/time-picker.scss');
require('../../input/style/index.js');
require('../../scrollbar/style/index.js');
require('../../popper/style/index.js');
//# sourceMappingURL=index.js.map

1
frontend/node_modules/element-plus/lib/components/time-picker/style/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}