init

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-basic-date-table.d.ts

@@ -0,0 +1,247 @@
+import dayjs from 'dayjs';
+import type { SetupContext } from 'vue';
+import type { DateCell } from '../types';
+import type { BasicDateTableEmits, BasicDateTableProps } from '../props/basic-date-table';
+export declare const useBasicDateTable: (props: BasicDateTableProps, emit: SetupContext<BasicDateTableEmits>["emit"]) => {
+    WEEKS: import("vue").ComputedRef<string[]>;
+    rows: import("vue").ComputedRef<{
+        column?: number | undefined;
+        customClass?: string | undefined;
+        disabled?: boolean | undefined;
+        end?: boolean | undefined;
+        inRange?: boolean | undefined;
+        row?: number | undefined;
+        selected?: {
+            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: dayjs.UnitType, value: number) => Dayjs;
+            get: (unit: dayjs.UnitType) => number;
+            add: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            subtract: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            startOf: (unit: dayjs.OpUnitType) => Dayjs;
+            endOf: (unit: dayjs.OpUnitType) => Dayjs;
+            format: (template?: string) => string;
+            diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+            valueOf: () => number;
+            unix: () => number;
+            daysInMonth: () => number;
+            toDate: () => Date;
+            toJSON: () => string;
+            toISOString: () => string;
+            toString: () => string;
+            utcOffset: () => number;
+            isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            locale: {
+                (): string;
+                (preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
+            };
+            localeData: () => dayjs.InstanceLocaleDataReturn;
+            week: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            weekYear: () => number;
+            dayOfYear: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            isSameOrAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSameOrBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        } | undefined;
+        isCurrent?: boolean | undefined;
+        isSelected?: boolean | undefined;
+        start?: boolean | undefined;
+        text?: number | undefined;
+        renderText?: string | undefined;
+        timestamp?: number | undefined;
+        date?: {
+            toString: () => string;
+            toDateString: () => string;
+            toTimeString: () => string;
+            toLocaleString: {
+                (): string;
+                (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+            };
+            toLocaleDateString: {
+                (): string;
+                (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+            };
+            toLocaleTimeString: {
+                (): string;
+                (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+            };
+            valueOf: () => number;
+            getTime: () => number;
+            getFullYear: () => number;
+            getUTCFullYear: () => number;
+            getMonth: () => number;
+            getUTCMonth: () => number;
+            getDate: () => number;
+            getUTCDate: () => number;
+            getDay: () => number;
+            getUTCDay: () => number;
+            getHours: () => number;
+            getUTCHours: () => number;
+            getMinutes: () => number;
+            getUTCMinutes: () => number;
+            getSeconds: () => number;
+            getUTCSeconds: () => number;
+            getMilliseconds: () => number;
+            getUTCMilliseconds: () => number;
+            getTimezoneOffset: () => number;
+            setTime: (time: number) => number;
+            setMilliseconds: (ms: number) => number;
+            setUTCMilliseconds: (ms: number) => number;
+            setSeconds: (sec: number, ms?: number) => number;
+            setUTCSeconds: (sec: number, ms?: number) => number;
+            setMinutes: (min: number, sec?: number, ms?: number) => number;
+            setUTCMinutes: (min: number, sec?: number, ms?: number) => number;
+            setHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
+            setUTCHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
+            setDate: (date: number) => number;
+            setUTCDate: (date: number) => number;
+            setMonth: (month: number, date?: number) => number;
+            setUTCMonth: (month: number, date?: number) => number;
+            setFullYear: (year: number, month?: number, date?: number) => number;
+            setUTCFullYear: (year: number, month?: number, date?: number) => number;
+            toUTCString: () => string;
+            toISOString: () => string;
+            toJSON: (key?: any) => string;
+            [Symbol.toPrimitive]: {
+                (hint: "default"): string;
+                (hint: "string"): string;
+                (hint: "number"): number;
+                (hint: string): string | number;
+            };
+        } | undefined;
+        dayjs?: {
+            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: dayjs.UnitType, value: number) => Dayjs;
+            get: (unit: dayjs.UnitType) => number;
+            add: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            subtract: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            startOf: (unit: dayjs.OpUnitType) => Dayjs;
+            endOf: (unit: dayjs.OpUnitType) => Dayjs;
+            format: (template?: string) => string;
+            diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+            valueOf: () => number;
+            unix: () => number;
+            daysInMonth: () => number;
+            toDate: () => Date;
+            toJSON: () => string;
+            toISOString: () => string;
+            toString: () => string;
+            utcOffset: () => number;
+            isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            locale: {
+                (): string;
+                (preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
+            };
+            localeData: () => dayjs.InstanceLocaleDataReturn;
+            week: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            weekYear: () => number;
+            dayOfYear: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            isSameOrAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSameOrBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        } | undefined;
+        type?: ("normal" | "week" | "today" | "prev-month" | "next-month") | undefined;
+    }[][]>;
+    tbodyRef: import("vue").Ref<HTMLElement | undefined>;
+    currentCellRef: import("vue").Ref<HTMLElement | undefined>;
+    focus: () => Promise<void | undefined>;
+    isCurrent: (cell: DateCell) => boolean;
+    isWeekActive: (cell: DateCell) => boolean;
+    isSelectedCell: (cell: DateCell) => boolean | undefined;
+    handlePickDate: (event: FocusEvent | MouseEvent, isKeyboardMovement?: boolean) => void;
+    handleMouseUp: (event: MouseEvent) => void;
+    handleMouseDown: (event: MouseEvent) => void;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleFocus: (event: FocusEvent) => void;
+};
+export declare const useBasicDateTableDOM: (props: BasicDateTableProps, { isCurrent, isWeekActive, }: Pick<ReturnType<typeof useBasicDateTable>, "isCurrent" | "isWeekActive">) => {
+    tableKls: import("vue").ComputedRef<(string | {
+        'is-week-mode': boolean;
+    })[]>;
+    tableLabel: import("vue").ComputedRef<string>;
+    weekHeaderClass: string;
+    getCellClasses: (cell: DateCell) => string;
+    getRowKls: (cell: DateCell) => (string | {
+        current: boolean;
+    })[];
+    t: import("element-plus/es/hooks").Translator;
+};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-basic-date-table.js

@@ -0,0 +1,358 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var lodashUnified = require('lodash-unified');
+var utils = require('../utils.js');
+var index = require('../../../../hooks/use-locale/index.js');
+var arrays = require('../../../../utils/arrays.js');
+var index$1 = require('../../../../hooks/use-namespace/index.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 isNormalDay = (type = "") => {
+  return ["normal", "today"].includes(type);
+};
+const useBasicDateTable = (props, emit) => {
+  const { lang } = index.useLocale();
+  const tbodyRef = vue.ref();
+  const currentCellRef = vue.ref();
+  const lastRow = vue.ref();
+  const lastColumn = vue.ref();
+  const tableRows = vue.ref([[], [], [], [], [], []]);
+  let focusWithClick = false;
+  const firstDayOfWeek = props.date.$locale().weekStart || 7;
+  const WEEKS_CONSTANT = props.date.locale("en").localeData().weekdaysShort().map((_) => _.toLowerCase());
+  const offsetDay = vue.computed(() => {
+    return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
+  });
+  const startDate = vue.computed(() => {
+    const startDayOfMonth = props.date.startOf("month");
+    return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
+  });
+  const WEEKS = vue.computed(() => {
+    return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(firstDayOfWeek, firstDayOfWeek + 7);
+  });
+  const hasCurrent = vue.computed(() => {
+    return lodashUnified.flatten(vue.unref(rows)).some((row) => {
+      return row.isCurrent;
+    });
+  });
+  const days = vue.computed(() => {
+    const startOfMonth = props.date.startOf("month");
+    const startOfMonthDay = startOfMonth.day() || 7;
+    const dateCountOfMonth = startOfMonth.daysInMonth();
+    const dateCountOfLastMonth = startOfMonth.subtract(1, "month").daysInMonth();
+    return {
+      startOfMonthDay,
+      dateCountOfMonth,
+      dateCountOfLastMonth
+    };
+  });
+  const selectedDate = vue.computed(() => {
+    return props.selectionMode === "dates" ? arrays.castArray(props.parsedValue) : [];
+  });
+  const setDateText = (cell, { count, rowIndex, columnIndex }) => {
+    const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = vue.unref(days);
+    const offset = vue.unref(offsetDay);
+    if (rowIndex >= 0 && rowIndex <= 1) {
+      const numberOfDaysFromPreviousMonth = startOfMonthDay + offset < 0 ? 7 + startOfMonthDay + offset : startOfMonthDay + offset;
+      if (columnIndex + rowIndex * 7 >= numberOfDaysFromPreviousMonth) {
+        cell.text = count;
+        return true;
+      } else {
+        cell.text = dateCountOfLastMonth - (numberOfDaysFromPreviousMonth - columnIndex % 7) + 1 + rowIndex * 7;
+        cell.type = "prev-month";
+      }
+    } else {
+      if (count <= dateCountOfMonth) {
+        cell.text = count;
+      } else {
+        cell.text = count - dateCountOfMonth;
+        cell.type = "next-month";
+      }
+      return true;
+    }
+    return false;
+  };
+  const setCellMetadata = (cell, { columnIndex, rowIndex }, count) => {
+    const { disabledDate, cellClassName } = props;
+    const _selectedDate = vue.unref(selectedDate);
+    const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
+    const cellDate = cell.dayjs.toDate();
+    cell.selected = _selectedDate.find((d) => d.isSame(cell.dayjs, "day"));
+    cell.isSelected = !!cell.selected;
+    cell.isCurrent = isCurrent(cell);
+    cell.disabled = disabledDate == null ? void 0 : disabledDate(cellDate);
+    cell.customClass = cellClassName == null ? void 0 : cellClassName(cellDate);
+    return shouldIncrement;
+  };
+  const setRowMetadata = (row) => {
+    if (props.selectionMode === "week") {
+      const [start, end] = props.showWeekNumber ? [1, 7] : [0, 6];
+      const isActive = isWeekActive(row[start + 1]);
+      row[start].inRange = isActive;
+      row[start].start = isActive;
+      row[end].inRange = isActive;
+      row[end].end = isActive;
+    }
+  };
+  const rows = vue.computed(() => {
+    const { minDate, maxDate, rangeState, showWeekNumber } = props;
+    const offset = vue.unref(offsetDay);
+    const rows_ = vue.unref(tableRows);
+    const dateUnit = "day";
+    let count = 1;
+    utils.buildPickerTable({ row: 6, column: 7 }, rows_, {
+      startDate: minDate,
+      columnIndexOffset: showWeekNumber ? 1 : 0,
+      nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
+      now: dayjs__default["default"]().locale(vue.unref(lang)).startOf(dateUnit),
+      unit: dateUnit,
+      relativeDateGetter: (idx) => vue.unref(startDate).add(idx - offset, dateUnit),
+      setCellMetadata: (...args) => {
+        if (setCellMetadata(...args, count)) {
+          count += 1;
+        }
+      },
+      setRowMetadata
+    });
+    if (showWeekNumber) {
+      for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
+        if (rows_[rowIndex][1].dayjs) {
+          rows_[rowIndex][0] = {
+            type: "week",
+            text: rows_[rowIndex][1].dayjs.week()
+          };
+        }
+      }
+    }
+    return rows_;
+  });
+  vue.watch(() => props.date, async () => {
+    var _a;
+    if ((_a = vue.unref(tbodyRef)) == null ? void 0 : _a.contains(document.activeElement)) {
+      await vue.nextTick();
+      await focus();
+    }
+  });
+  const focus = async () => {
+    var _a;
+    return (_a = vue.unref(currentCellRef)) == null ? void 0 : _a.focus();
+  };
+  const isCurrent = (cell) => {
+    return props.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props.parsedValue);
+  };
+  const cellMatchesDate = (cell, date) => {
+    if (!date)
+      return false;
+    return dayjs__default["default"](date).locale(vue.unref(lang)).isSame(props.date.date(Number(cell.text)), "day");
+  };
+  const getDateOfCell = (row, column) => {
+    const offsetFromStart = row * 7 + (column - (props.showWeekNumber ? 1 : 0)) - vue.unref(offsetDay);
+    return vue.unref(startDate).add(offsetFromStart, "day");
+  };
+  const handleMouseMove = (event) => {
+    var _a;
+    if (!props.rangeState.selecting)
+      return;
+    let target = event.target;
+    if (target.tagName === "SPAN") {
+      target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
+    }
+    if (target.tagName === "DIV") {
+      target = target.parentNode;
+    }
+    if (target.tagName !== "TD")
+      return;
+    const row = target.parentNode.rowIndex - 1;
+    const column = target.cellIndex;
+    if (vue.unref(rows)[row][column].disabled)
+      return;
+    if (row !== vue.unref(lastRow) || column !== vue.unref(lastColumn)) {
+      lastRow.value = row;
+      lastColumn.value = column;
+      emit("changerange", {
+        selecting: true,
+        endDate: getDateOfCell(row, column)
+      });
+    }
+  };
+  const isSelectedCell = (cell) => {
+    return !vue.unref(hasCurrent) && (cell == null ? void 0 : cell.text) === 1 && cell.type === "normal" || cell.isCurrent;
+  };
+  const handleFocus = (event) => {
+    if (focusWithClick || vue.unref(hasCurrent) || props.selectionMode !== "date")
+      return;
+    handlePickDate(event, true);
+  };
+  const handleMouseDown = (event) => {
+    const target = event.target.closest("td");
+    if (!target)
+      return;
+    focusWithClick = true;
+  };
+  const handleMouseUp = (event) => {
+    const target = event.target.closest("td");
+    if (!target)
+      return;
+    focusWithClick = false;
+  };
+  const handleRangePick = (newDate) => {
+    if (!props.rangeState.selecting || !props.minDate) {
+      emit("pick", { minDate: newDate, maxDate: null });
+      emit("select", true);
+    } else {
+      if (newDate >= props.minDate) {
+        emit("pick", { minDate: props.minDate, maxDate: newDate });
+      } else {
+        emit("pick", { minDate: newDate, maxDate: props.minDate });
+      }
+      emit("select", false);
+    }
+  };
+  const handleWeekPick = (newDate) => {
+    const weekNumber = newDate.week();
+    const value = `${newDate.year()}w${weekNumber}`;
+    emit("pick", {
+      year: newDate.year(),
+      week: weekNumber,
+      value,
+      date: newDate.startOf("week")
+    });
+  };
+  const handleDatesPick = (newDate, selected) => {
+    const newValue = selected ? arrays.castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.valueOf()) !== newDate.valueOf()) : arrays.castArray(props.parsedValue).concat([newDate]);
+    emit("pick", newValue);
+  };
+  const handlePickDate = (event, isKeyboardMovement = false) => {
+    if (props.disabled)
+      return;
+    const target = event.target.closest("td");
+    if (!target)
+      return;
+    const row = target.parentNode.rowIndex - 1;
+    const column = target.cellIndex;
+    const cell = vue.unref(rows)[row][column];
+    if (cell.disabled || cell.type === "week")
+      return;
+    const newDate = getDateOfCell(row, column);
+    switch (props.selectionMode) {
+      case "range": {
+        handleRangePick(newDate);
+        break;
+      }
+      case "date": {
+        emit("pick", newDate, isKeyboardMovement);
+        break;
+      }
+      case "week": {
+        handleWeekPick(newDate);
+        break;
+      }
+      case "dates": {
+        handleDatesPick(newDate, !!cell.selected);
+        break;
+      }
+    }
+  };
+  const isWeekActive = (cell) => {
+    if (props.selectionMode !== "week")
+      return false;
+    let newDate = props.date.startOf("day");
+    if (cell.type === "prev-month") {
+      newDate = newDate.subtract(1, "month");
+    }
+    if (cell.type === "next-month") {
+      newDate = newDate.add(1, "month");
+    }
+    newDate = newDate.date(Number.parseInt(cell.text, 10));
+    if (props.parsedValue && !shared.isArray(props.parsedValue)) {
+      const dayOffset = (props.parsedValue.day() - firstDayOfWeek + 7) % 7 - 1;
+      const weekDate = props.parsedValue.subtract(dayOffset, "day");
+      return weekDate.isSame(newDate, "day");
+    }
+    return false;
+  };
+  return {
+    WEEKS,
+    rows,
+    tbodyRef,
+    currentCellRef,
+    focus,
+    isCurrent,
+    isWeekActive,
+    isSelectedCell,
+    handlePickDate,
+    handleMouseUp,
+    handleMouseDown,
+    handleMouseMove,
+    handleFocus
+  };
+};
+const useBasicDateTableDOM = (props, {
+  isCurrent,
+  isWeekActive
+}) => {
+  const ns = index$1.useNamespace("date-table");
+  const { t } = index.useLocale();
+  const tableKls = vue.computed(() => [
+    ns.b(),
+    { "is-week-mode": props.selectionMode === "week" && !props.disabled }
+  ]);
+  const tableLabel = vue.computed(() => t("el.datepicker.dateTablePrompt"));
+  const getCellClasses = (cell) => {
+    const classes = [];
+    if (isNormalDay(cell.type) && !cell.disabled) {
+      classes.push("available");
+      if (cell.type === "today") {
+        classes.push("today");
+      }
+    } else {
+      classes.push(cell.type);
+    }
+    if (isCurrent(cell)) {
+      classes.push("current");
+    }
+    if (cell.inRange && (isNormalDay(cell.type) || props.selectionMode === "week")) {
+      classes.push("in-range");
+      if (cell.start) {
+        classes.push("start-date");
+      }
+      if (cell.end) {
+        classes.push("end-date");
+      }
+    }
+    if (cell.disabled || props.disabled) {
+      classes.push("disabled");
+    }
+    if (cell.selected) {
+      classes.push("selected");
+    }
+    if (cell.customClass) {
+      classes.push(cell.customClass);
+    }
+    return classes.join(" ");
+  };
+  const getRowKls = (cell) => [
+    ns.e("row"),
+    { current: isWeekActive(cell) }
+  ];
+  return {
+    tableKls,
+    tableLabel,
+    weekHeaderClass: ns.e("week-header"),
+    getCellClasses,
+    getRowKls,
+    t
+  };
+};
+
+exports.useBasicDateTable = useBasicDateTable;
+exports.useBasicDateTableDOM = useBasicDateTableDOM;
+//# sourceMappingURL=use-basic-date-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-month-range-header.d.ts

@@ -0,0 +1,16 @@
+import type { Ref, ToRef } from 'vue';
+import type { Dayjs } from 'dayjs';
+export declare const useMonthRangeHeader: ({ unlinkPanels, leftDate, rightDate, }: {
+    unlinkPanels: ToRef<boolean>;
+    leftDate: Ref<Dayjs>;
+    rightDate: Ref<Dayjs>;
+}) => {
+    leftPrevYear: () => void;
+    rightNextYear: () => void;
+    leftNextYear: () => void;
+    rightPrevYear: () => void;
+    leftLabel: import("vue").ComputedRef<string>;
+    rightLabel: import("vue").ComputedRef<string>;
+    leftYear: import("vue").ComputedRef<number>;
+    rightYear: import("vue").ComputedRef<number>;
+};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-month-range-header.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../../hooks/use-locale/index.js');
+
+const useMonthRangeHeader = ({
+  unlinkPanels,
+  leftDate,
+  rightDate
+}) => {
+  const { t } = index.useLocale();
+  const leftPrevYear = () => {
+    leftDate.value = leftDate.value.subtract(1, "year");
+    if (!unlinkPanels.value) {
+      rightDate.value = rightDate.value.subtract(1, "year");
+    }
+  };
+  const rightNextYear = () => {
+    if (!unlinkPanels.value) {
+      leftDate.value = leftDate.value.add(1, "year");
+    }
+    rightDate.value = rightDate.value.add(1, "year");
+  };
+  const leftNextYear = () => {
+    leftDate.value = leftDate.value.add(1, "year");
+  };
+  const rightPrevYear = () => {
+    rightDate.value = rightDate.value.subtract(1, "year");
+  };
+  const leftLabel = vue.computed(() => {
+    return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
+  });
+  const rightLabel = vue.computed(() => {
+    return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
+  });
+  const leftYear = vue.computed(() => {
+    return leftDate.value.year();
+  });
+  const rightYear = vue.computed(() => {
+    return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
+  });
+  return {
+    leftPrevYear,
+    rightNextYear,
+    leftNextYear,
+    rightPrevYear,
+    leftLabel,
+    rightLabel,
+    leftYear,
+    rightYear
+  };
+};
+
+exports.useMonthRangeHeader = useMonthRangeHeader;
+//# sourceMappingURL=use-month-range-header.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-month-range-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-month-range-header.js","sources":["../../../../../../../packages/components/date-picker-panel/src/composables/use-month-range-header.ts"],"sourcesContent":["import { computed } from 'vue'\nimport { useLocale } from '@element-plus/hooks'\n\nimport type { Ref, ToRef } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const useMonthRangeHeader = ({\n  unlinkPanels,\n  leftDate,\n  rightDate,\n}: {\n  unlinkPanels: ToRef<boolean>\n  leftDate: Ref<Dayjs>\n  rightDate: Ref<Dayjs>\n}) => {\n  const { t } = useLocale()\n  const leftPrevYear = () => {\n    leftDate.value = leftDate.value.subtract(1, 'year')\n    if (!unlinkPanels.value) {\n      rightDate.value = rightDate.value.subtract(1, 'year')\n    }\n  }\n\n  const rightNextYear = () => {\n    if (!unlinkPanels.value) {\n      leftDate.value = leftDate.value.add(1, 'year')\n    }\n    rightDate.value = rightDate.value.add(1, 'year')\n  }\n\n  const leftNextYear = () => {\n    leftDate.value = leftDate.value.add(1, 'year')\n  }\n\n  const rightPrevYear = () => {\n    rightDate.value = rightDate.value.subtract(1, 'year')\n  }\n  const leftLabel = computed(() => {\n    return `${leftDate.value.year()} ${t('el.datepicker.year')}`\n  })\n\n  const rightLabel = computed(() => {\n    return `${rightDate.value.year()} ${t('el.datepicker.year')}`\n  })\n\n  const leftYear = computed(() => {\n    return leftDate.value.year()\n  })\n\n  const rightYear = computed(() => {\n    return rightDate.value.year() === leftDate.value.year()\n      ? leftDate.value.year() + 1\n      : rightDate.value.year()\n  })\n\n  return {\n    leftPrevYear,\n    rightNextYear,\n    leftNextYear,\n    rightPrevYear,\n    leftLabel,\n    rightLabel,\n    leftYear,\n    rightYear,\n  }\n}\n"],"names":["useLocale","computed"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAG,CAAC;AACpC,EAAE,YAAY;AACd,EAAE,QAAQ;AACV,EAAE,SAAS;AACX,CAAC,KAAK;AACN,EAAE,MAAM,EAAE,CAAC,EAAE,GAAGA,eAAS,EAAE,CAAC;AAC5B,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACxD,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC5D,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACrD,KAAK;AACL,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACrD,GAAG,CAAC;AACJ,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACnD,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC1D,GAAG,CAAC;AACJ,EAAE,MAAM,SAAS,GAAGC,YAAQ,CAAC,MAAM;AACnC,IAAI,OAAO,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;AACjE,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,UAAU,GAAGA,YAAQ,CAAC,MAAM;AACpC,IAAI,OAAO,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAClE,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,QAAQ,GAAGA,YAAQ,CAAC,MAAM;AAClC,IAAI,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;AACjC,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,SAAS,GAAGA,YAAQ,CAAC,MAAM;AACnC,IAAI,OAAO,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;AACjH,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,QAAQ;AACZ,IAAI,SAAS;AACb,GAAG,CAAC;AACJ;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-panel-date-range.d.ts

@@ -0,0 +1,29 @@
+import type { PanelDateRangeProps } from '../props/panel-date-range';
+import type { Dayjs } from 'dayjs';
+import type { ComputedRef, Ref } from 'vue';
+type CurrentView = 'date' | 'year' | 'month';
+type CurrentViewRef = {
+    focus: () => void;
+};
+export type Emits = (event: 'pick' | 'set-picker-option' | 'calendar-change' | 'panel-change', ...args: any[]) => void;
+export declare const usePanelDateRange: (props: PanelDateRangeProps, emit: Emits, leftDate: Ref<Dayjs>, rightDate: Ref<Dayjs>) => {
+    leftCurrentView: Ref<CurrentView>;
+    rightCurrentView: Ref<CurrentView>;
+    leftCurrentViewRef: Ref<CurrentViewRef | undefined>;
+    rightCurrentViewRef: Ref<CurrentViewRef | undefined>;
+    leftYear: ComputedRef<number>;
+    rightYear: ComputedRef<number>;
+    leftMonth: ComputedRef<number>;
+    rightMonth: ComputedRef<number>;
+    leftYearLabel: ComputedRef<string>;
+    rightYearLabel: ComputedRef<string>;
+    showLeftPicker: (view: "month" | "year") => Promise<void>;
+    showRightPicker: (view: "month" | "year") => Promise<void>;
+    handleLeftYearPick: (year: number) => Promise<void>;
+    handleRightYearPick: (year: number) => Promise<void>;
+    handleLeftMonthPick: (month: number) => Promise<void>;
+    handleRightMonthPick: (month: number) => Promise<void>;
+    handlePanelChange: (mode: "month" | "year") => void;
+    adjustDateByView: (currentView: CurrentView, date: Dayjs, forward: boolean) => Dayjs;
+};
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-panel-date-range.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var utils = require('../utils.js');
+var constants = require('../../../time-picker/src/constants.js');
+var index = require('../../../../hooks/use-locale/index.js');
+
+const usePanelDateRange = (props, emit, leftDate, rightDate) => {
+  const leftCurrentView = vue.ref("date");
+  const leftCurrentViewRef = vue.ref();
+  const rightCurrentView = vue.ref("date");
+  const rightCurrentViewRef = vue.ref();
+  const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
+  const { disabledDate } = pickerBase.props;
+  const { t, lang } = index.useLocale();
+  const leftYear = vue.computed(() => {
+    return leftDate.value.year();
+  });
+  const leftMonth = vue.computed(() => {
+    return leftDate.value.month();
+  });
+  const rightYear = vue.computed(() => {
+    return rightDate.value.year();
+  });
+  const rightMonth = vue.computed(() => {
+    return rightDate.value.month();
+  });
+  function computedYearLabel(currentView, yearValue) {
+    const yearTranslation = t("el.datepicker.year");
+    if (currentView.value === "year") {
+      const startYear = Math.floor(yearValue.value / 10) * 10;
+      return yearTranslation ? `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}` : `${startYear} - ${startYear + 9}`;
+    }
+    return `${yearValue.value} ${yearTranslation}`;
+  }
+  function focusPicker(currentViewRef) {
+    currentViewRef == null ? void 0 : currentViewRef.focus();
+  }
+  async function showPicker(pickerType, view) {
+    if (props.disabled)
+      return;
+    const currentView = pickerType === "left" ? leftCurrentView : rightCurrentView;
+    const currentViewRef = pickerType === "left" ? leftCurrentViewRef : rightCurrentViewRef;
+    currentView.value = view;
+    await vue.nextTick();
+    focusPicker(currentViewRef.value);
+  }
+  async function handlePick(mode, pickerType, value) {
+    if (props.disabled)
+      return;
+    const isLeftPicker = pickerType === "left";
+    const startDate = isLeftPicker ? leftDate : rightDate;
+    const endDate = isLeftPicker ? rightDate : leftDate;
+    const currentView = isLeftPicker ? leftCurrentView : rightCurrentView;
+    const currentViewRef = isLeftPicker ? leftCurrentViewRef : rightCurrentViewRef;
+    if (mode === "year") {
+      const data = startDate.value.year(value);
+      startDate.value = utils.getValidDateOfYear(data, lang.value, disabledDate);
+    }
+    if (mode === "month") {
+      startDate.value = utils.getValidDateOfMonth(startDate.value, startDate.value.year(), value, lang.value, disabledDate);
+    }
+    if (!props.unlinkPanels) {
+      endDate.value = pickerType === "left" ? startDate.value.add(1, "month") : startDate.value.subtract(1, "month");
+    }
+    currentView.value = mode === "year" ? "month" : "date";
+    await vue.nextTick();
+    focusPicker(currentViewRef.value);
+    handlePanelChange(mode);
+  }
+  function handlePanelChange(mode) {
+    emit("panel-change", [leftDate.value.toDate(), rightDate.value.toDate()], mode);
+  }
+  function adjustDateByView(currentView, date, forward) {
+    const action = forward ? "add" : "subtract";
+    return currentView === "year" ? date[action](10, "year") : date[action](1, "year");
+  }
+  return {
+    leftCurrentView,
+    rightCurrentView,
+    leftCurrentViewRef,
+    rightCurrentViewRef,
+    leftYear,
+    rightYear,
+    leftMonth,
+    rightMonth,
+    leftYearLabel: vue.computed(() => computedYearLabel(leftCurrentView, leftYear)),
+    rightYearLabel: vue.computed(() => computedYearLabel(rightCurrentView, rightYear)),
+    showLeftPicker: (view) => showPicker("left", view),
+    showRightPicker: (view) => showPicker("right", view),
+    handleLeftYearPick: (year) => handlePick("year", "left", year),
+    handleRightYearPick: (year) => handlePick("year", "right", year),
+    handleLeftMonthPick: (month) => handlePick("month", "left", month),
+    handleRightMonthPick: (month) => handlePick("month", "right", month),
+    handlePanelChange,
+    adjustDateByView
+  };
+};
+
+exports.usePanelDateRange = usePanelDateRange;
+//# sourceMappingURL=use-panel-date-range.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-range-picker.d.ts

@@ -0,0 +1,136 @@
+import dayjs from 'dayjs';
+import type { Ref } from 'vue';
+import type { Dayjs } from 'dayjs';
+import type { PanelRangeSharedProps, RangeState } from '../props/shared';
+import type { DefaultValue } from '../utils';
+type UseRangePickerProps = {
+    sortDates: (minDate: Dayjs | undefined, maxDate: Dayjs | undefined) => void;
+    defaultValue: Ref<DefaultValue>;
+    defaultTime?: Ref<DefaultValue>;
+    leftDate: Ref<Dayjs>;
+    rightDate: Ref<Dayjs>;
+    step?: number;
+    unit: 'month' | 'year';
+};
+export declare const useRangePicker: (props: PanelRangeSharedProps, { defaultValue, defaultTime, leftDate, rightDate, step, unit, sortDates, }: UseRangePickerProps) => {
+    minDate: Ref<dayjs.Dayjs | undefined>;
+    maxDate: Ref<dayjs.Dayjs | undefined>;
+    rangeState: Ref<{
+        endDate: {
+            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: dayjs.UnitType, value: number) => Dayjs;
+            get: (unit: dayjs.UnitType) => number;
+            add: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            subtract: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            startOf: (unit: dayjs.OpUnitType) => Dayjs;
+            endOf: (unit: dayjs.OpUnitType) => Dayjs;
+            format: (template?: string) => string;
+            diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+            valueOf: () => number;
+            unix: () => number;
+            daysInMonth: () => number;
+            toDate: () => Date;
+            toJSON: () => string;
+            toISOString: () => string;
+            toString: () => string;
+            utcOffset: () => number;
+            isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            locale: {
+                (): string;
+                (preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
+            };
+            localeData: () => dayjs.InstanceLocaleDataReturn;
+            week: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            weekYear: () => number;
+            dayOfYear: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            isSameOrAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSameOrBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        } | null;
+        selecting: boolean;
+    }>;
+    lang: Ref<string>;
+    ppNs: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    drpNs: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    handleChangeRange: (val: RangeState) => void;
+    handleRangeConfirm: (visible?: boolean) => void;
+    handleShortcutClick: (shortcut: import("./use-shortcut").Shortcut) => void;
+    onSelect: (selecting: boolean) => void;
+    parseValue: (parsedValue: PanelRangeSharedProps["parsedValue"]) => void;
+    t: import("element-plus/es/hooks").Translator;
+};
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-range-picker.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var lodashUnified = require('lodash-unified');
+var utils = require('../utils.js');
+var constants = require('../constants.js');
+var useShortcut = require('./use-shortcut.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+var index$1 = require('../../../../hooks/use-locale/index.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 useRangePicker = (props, {
+  defaultValue,
+  defaultTime,
+  leftDate,
+  rightDate,
+  step,
+  unit,
+  sortDates
+}) => {
+  const { emit } = vue.getCurrentInstance();
+  const { pickerNs } = vue.inject(constants.ROOT_PICKER_INJECTION_KEY);
+  const drpNs = index.useNamespace("date-range-picker");
+  const { t, lang } = index$1.useLocale();
+  const handleShortcutClick = useShortcut.useShortcut(lang);
+  const minDate = vue.ref();
+  const maxDate = vue.ref();
+  const rangeState = vue.ref({
+    endDate: null,
+    selecting: false
+  });
+  const handleChangeRange = (val) => {
+    rangeState.value = val;
+  };
+  const handleRangeConfirm = (visible = false) => {
+    const _minDate = vue.unref(minDate);
+    const _maxDate = vue.unref(maxDate);
+    if (utils.isValidRange([_minDate, _maxDate])) {
+      emit("pick", [_minDate, _maxDate], visible);
+    }
+  };
+  const onSelect = (selecting) => {
+    rangeState.value.selecting = selecting;
+    if (!selecting) {
+      rangeState.value.endDate = null;
+    }
+  };
+  const parseValue = (parsedValue) => {
+    if (shared.isArray(parsedValue) && parsedValue.length === 2) {
+      const [start, end] = parsedValue;
+      minDate.value = start;
+      leftDate.value = start;
+      maxDate.value = end;
+      sortDates(vue.unref(minDate), vue.unref(maxDate));
+    } else {
+      restoreDefault();
+    }
+  };
+  const restoreDefault = () => {
+    let [start, end] = utils.getDefaultValue(vue.unref(defaultValue), {
+      lang: vue.unref(lang),
+      step,
+      unit,
+      unlinkPanels: props.unlinkPanels
+    });
+    const getShift = (day) => {
+      return day.diff(day.startOf("d"), "ms");
+    };
+    const maybeTimes = vue.unref(defaultTime);
+    if (maybeTimes) {
+      let leftShift = 0;
+      let rightShift = 0;
+      if (shared.isArray(maybeTimes)) {
+        const [timeStart, timeEnd] = maybeTimes.map(dayjs__default["default"]);
+        leftShift = getShift(timeStart);
+        rightShift = getShift(timeEnd);
+      } else {
+        const shift = getShift(dayjs__default["default"](maybeTimes));
+        leftShift = shift;
+        rightShift = shift;
+      }
+      start = start.startOf("d").add(leftShift, "ms");
+      end = end.startOf("d").add(rightShift, "ms");
+    }
+    minDate.value = void 0;
+    maxDate.value = void 0;
+    leftDate.value = start;
+    rightDate.value = end;
+  };
+  vue.watch(defaultValue, (val) => {
+    if (val) {
+      restoreDefault();
+    }
+  }, { immediate: true });
+  vue.watch(() => props.parsedValue, (parsedValue) => {
+    if (!(parsedValue == null ? void 0 : parsedValue.length) || !lodashUnified.isEqual(parsedValue, [minDate.value, maxDate.value])) {
+      parseValue(parsedValue);
+    }
+  }, {
+    immediate: true
+  });
+  vue.watch(() => props.visible, () => {
+    if (props.visible) {
+      parseValue(props.parsedValue);
+    }
+  }, { immediate: true });
+  return {
+    minDate,
+    maxDate,
+    rangeState,
+    lang,
+    ppNs: pickerNs,
+    drpNs,
+    handleChangeRange,
+    handleRangeConfirm,
+    handleShortcutClick,
+    onSelect,
+    parseValue,
+    t
+  };
+};
+
+exports.useRangePicker = useRangePicker;
+//# sourceMappingURL=use-range-picker.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-shortcut.d.ts

@@ -0,0 +1,9 @@
+import type { SetupContext } from 'vue';
+import type { useLocale } from 'element-plus/es/hooks';
+import type { RangePickerSharedEmits } from '../props/shared';
+export type Shortcut = {
+    text: string;
+    value: [Date, Date] | (() => [Date, Date]);
+    onClick?: (ctx: Omit<SetupContext<RangePickerSharedEmits>, 'expose'>) => void;
+};
+export declare const useShortcut: (lang: ReturnType<typeof useLocale>["lang"]) => (shortcut: Shortcut) => void;

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-shortcut.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+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 useShortcut = (lang) => {
+  const { emit } = vue.getCurrentInstance();
+  const attrs = vue.useAttrs();
+  const slots = vue.useSlots();
+  const handleShortcutClick = (shortcut) => {
+    const shortcutValues = shared.isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
+    if (shortcutValues) {
+      emit("pick", [
+        dayjs__default["default"](shortcutValues[0]).locale(lang.value),
+        dayjs__default["default"](shortcutValues[1]).locale(lang.value)
+      ]);
+      return;
+    }
+    if (shortcut.onClick) {
+      shortcut.onClick({
+        attrs,
+        slots,
+        emit
+      });
+    }
+  };
+  return handleShortcutClick;
+};
+
+exports.useShortcut = useShortcut;
+//# sourceMappingURL=use-shortcut.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-shortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-shortcut.js","sources":["../../../../../../../packages/components/date-picker-panel/src/composables/use-shortcut.ts"],"sourcesContent":["import { getCurrentInstance, useAttrs, useSlots } from 'vue'\nimport dayjs from 'dayjs'\nimport { isFunction } from '@element-plus/utils'\n\nimport type { SetupContext } from 'vue'\nimport type { useLocale } from '@element-plus/hooks'\nimport type { RangePickerSharedEmits } from '../props/shared'\n\n// FIXME: extract this to `date-picker.ts`\nexport type Shortcut = {\n  text: string\n  value: [Date, Date] | (() => [Date, Date])\n  onClick?: (ctx: Omit<SetupContext<RangePickerSharedEmits>, 'expose'>) => void\n}\n\nexport const useShortcut = (lang: ReturnType<typeof useLocale>['lang']) => {\n  const { emit } = getCurrentInstance()!\n  const attrs = useAttrs()\n  const slots = useSlots()\n\n  const handleShortcutClick = (shortcut: Shortcut) => {\n    const shortcutValues = isFunction(shortcut.value)\n      ? shortcut.value()\n      : shortcut.value\n\n    if (shortcutValues) {\n      emit('pick', [\n        dayjs(shortcutValues[0]).locale(lang.value),\n        dayjs(shortcutValues[1]).locale(lang.value),\n      ])\n      return\n    }\n    if (shortcut.onClick) {\n      shortcut.onClick({\n        attrs,\n        slots,\n        emit,\n      })\n    }\n  }\n\n  return handleShortcutClick\n}\n"],"names":["getCurrentInstance","useAttrs","useSlots","isFunction","dayjs"],"mappings":";;;;;;;;;;;;AAGY,MAAC,WAAW,GAAG,CAAC,IAAI,KAAK;AACrC,EAAE,MAAM,EAAE,IAAI,EAAE,GAAGA,sBAAkB,EAAE,CAAC;AACxC,EAAE,MAAM,KAAK,GAAGC,YAAQ,EAAE,CAAC;AAC3B,EAAE,MAAM,KAAK,GAAGC,YAAQ,EAAE,CAAC;AAC3B,EAAE,MAAM,mBAAmB,GAAG,CAAC,QAAQ,KAAK;AAC5C,IAAI,MAAM,cAAc,GAAGC,iBAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,KAAK,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC;AAC1F,IAAI,IAAI,cAAc,EAAE;AACxB,MAAM,IAAI,CAAC,MAAM,EAAE;AACnB,QAAQC,yBAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;AACnD,QAAQA,yBAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;AACnD,OAAO,CAAC,CAAC;AACT,MAAM,OAAO;AACb,KAAK;AACL,IAAI,IAAI,QAAQ,CAAC,OAAO,EAAE;AAC1B,MAAM,QAAQ,CAAC,OAAO,CAAC;AACvB,QAAQ,KAAK;AACb,QAAQ,KAAK;AACb,QAAQ,IAAI;AACZ,OAAO,CAAC,CAAC;AACT,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,OAAO,mBAAmB,CAAC;AAC7B;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-year-range-header.d.ts

@@ -0,0 +1,16 @@
+import type { Ref, ToRef } from 'vue';
+import type { Dayjs } from 'dayjs';
+export declare const useYearRangeHeader: ({ unlinkPanels, leftDate, rightDate, }: {
+    unlinkPanels: ToRef<boolean>;
+    leftDate: Ref<Dayjs>;
+    rightDate: Ref<Dayjs>;
+}) => {
+    leftPrevYear: () => void;
+    rightNextYear: () => void;
+    leftNextYear: () => void;
+    rightPrevYear: () => void;
+    leftLabel: import("vue").ComputedRef<string>;
+    rightLabel: import("vue").ComputedRef<string>;
+    leftYear: import("vue").ComputedRef<number>;
+    rightYear: import("vue").ComputedRef<number>;
+};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-year-range-header.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const useYearRangeHeader = ({
+  unlinkPanels,
+  leftDate,
+  rightDate
+}) => {
+  const leftPrevYear = () => {
+    leftDate.value = leftDate.value.subtract(10, "year");
+    if (!unlinkPanels.value) {
+      rightDate.value = rightDate.value.subtract(10, "year");
+    }
+  };
+  const rightNextYear = () => {
+    if (!unlinkPanels.value) {
+      leftDate.value = leftDate.value.add(10, "year");
+    }
+    rightDate.value = rightDate.value.add(10, "year");
+  };
+  const leftNextYear = () => {
+    leftDate.value = leftDate.value.add(10, "year");
+  };
+  const rightPrevYear = () => {
+    rightDate.value = rightDate.value.subtract(10, "year");
+  };
+  const leftLabel = vue.computed(() => {
+    const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10;
+    return `${leftStartDate}-${leftStartDate + 9}`;
+  });
+  const rightLabel = vue.computed(() => {
+    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
+    return `${rightStartDate}-${rightStartDate + 9}`;
+  });
+  const leftYear = vue.computed(() => {
+    const leftEndDate = Math.floor(leftDate.value.year() / 10) * 10 + 9;
+    return leftEndDate;
+  });
+  const rightYear = vue.computed(() => {
+    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
+    return rightStartDate;
+  });
+  return {
+    leftPrevYear,
+    rightNextYear,
+    leftNextYear,
+    rightPrevYear,
+    leftLabel,
+    rightLabel,
+    leftYear,
+    rightYear
+  };
+};
+
+exports.useYearRangeHeader = useYearRangeHeader;
+//# sourceMappingURL=use-year-range-header.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-year-range-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-year-range-header.js","sources":["../../../../../../../packages/components/date-picker-panel/src/composables/use-year-range-header.ts"],"sourcesContent":["import { computed } from 'vue'\n\nimport type { Ref, ToRef } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const useYearRangeHeader = ({\n  unlinkPanels,\n  leftDate,\n  rightDate,\n}: {\n  unlinkPanels: ToRef<boolean>\n  leftDate: Ref<Dayjs>\n  rightDate: Ref<Dayjs>\n}) => {\n  const leftPrevYear = () => {\n    leftDate.value = leftDate.value.subtract(10, 'year')\n    if (!unlinkPanels.value) {\n      rightDate.value = rightDate.value.subtract(10, 'year')\n    }\n  }\n\n  const rightNextYear = () => {\n    if (!unlinkPanels.value) {\n      leftDate.value = leftDate.value.add(10, 'year')\n    }\n    rightDate.value = rightDate.value.add(10, 'year')\n  }\n\n  const leftNextYear = () => {\n    leftDate.value = leftDate.value.add(10, 'year')\n  }\n\n  const rightPrevYear = () => {\n    rightDate.value = rightDate.value.subtract(10, 'year')\n  }\n\n  const leftLabel = computed(() => {\n    const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10\n    return `${leftStartDate}-${leftStartDate + 9}`\n  })\n\n  const rightLabel = computed(() => {\n    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10\n    return `${rightStartDate}-${rightStartDate + 9}`\n  })\n\n  const leftYear = computed(() => {\n    const leftEndDate = Math.floor(leftDate.value.year() / 10) * 10 + 9\n    return leftEndDate\n  })\n\n  const rightYear = computed(() => {\n    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10\n    return rightStartDate\n  })\n\n  return {\n    leftPrevYear,\n    rightNextYear,\n    leftNextYear,\n    rightPrevYear,\n    leftLabel,\n    rightLabel,\n    leftYear,\n    rightYear,\n  }\n}\n"],"names":["computed"],"mappings":";;;;;;AACY,MAAC,kBAAkB,GAAG,CAAC;AACnC,EAAE,YAAY;AACd,EAAE,QAAQ;AACV,EAAE,SAAS;AACX,CAAC,KAAK;AACN,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACzD,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AAC7D,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACtD,KAAK;AACL,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACtD,GAAG,CAAC;AACJ,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACpD,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AAC3D,GAAG,CAAC;AACJ,EAAE,MAAM,SAAS,GAAGA,YAAQ,CAAC,MAAM;AACnC,IAAI,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACtE,IAAI,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC;AACnD,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,UAAU,GAAGA,YAAQ,CAAC,MAAM;AACpC,IAAI,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACxE,IAAI,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC;AACrD,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,QAAQ,GAAGA,YAAQ,CAAC,MAAM;AAClC,IAAI,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACxE,IAAI,OAAO,WAAW,CAAC;AACvB,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,SAAS,GAAGA,YAAQ,CAAC,MAAM;AACnC,IAAI,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACxE,IAAI,OAAO,cAAc,CAAC;AAC1B,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,QAAQ;AACZ,IAAI,SAAS;AACb,GAAG,CAAC;AACJ;;;;"}