ep-craft 0.1.25 → 0.1.26

package/dist/components/date-picker/src/props.d.ts

@@ -0,0 +1,205 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { DatePickerType } from '@element-plus/components/date-picker-panel/src/types';
+export declare const datePickerProps: {
+    readonly type: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => DatePickerType) | (((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => DatePickerType)) | null)[], unknown, unknown, "date", boolean>;
+    readonly floatLabel: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly showNow: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showFooter: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly ariaLabel: StringConstructor;
+    readonly emptyValues: ArrayConstructor;
+    readonly valueOnClear: import("@element-plus/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)) | 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/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+    readonly arrowControl: BooleanConstructor;
+    readonly tabindex: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly unlinkPanels: BooleanConstructor;
+    readonly singlePanel: BooleanConstructor;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "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[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, "bottom", boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
+    readonly disabledHours: {
+        readonly type: import("vue").PropType<import("@element-plus/components/time-picker").GetDisabledHours>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledMinutes: {
+        readonly type: import("vue").PropType<import("@element-plus/components/time-picker").GetDisabledMinutes>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledSeconds: {
+        readonly type: import("vue").PropType<import("@element-plus/components/time-picker").GetDisabledSeconds>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly automaticDropdown: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly id: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("@element-plus/components/time-picker").SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => import("@element-plus/components/time-picker").SingleOrRange<string>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly name: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => import("@element-plus/components/time-picker").SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => import("@element-plus/components/time-picker").SingleOrRange<string>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/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;
+        } | /*elided*/ 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;
+        } | /*elided*/ 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;
+        } | /*elided*/ 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;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly format: StringConstructor;
+    readonly valueFormat: StringConstructor;
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly clearable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly clearIcon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+    readonly editable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly saveOnBlur: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly prefixIcon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, "", boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly readonly: BooleanConstructor;
+    readonly disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly placeholder: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly popperOptions: import("@element-plus/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>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => import("@element-plus/components/time-picker").ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => import("@element-plus/components/time-picker").ModelValueType | null)) | null)[], unknown, unknown, "", boolean>;
+    readonly rangeSeparator: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+    readonly startPlaceholder: StringConstructor;
+    readonly endPlaceholder: StringConstructor;
+    readonly defaultValue: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("@element-plus/components/time-picker").SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => import("@element-plus/components/time-picker").SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultTime: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("@element-plus/components/time-picker").SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => import("@element-plus/components/time-picker").SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly isRange: BooleanConstructor;
+};
+export type DatePickerProps = ExtractPropTypes<typeof datePickerProps>;
+export type DatePickerPropsPublic = ExtractPublicPropTypes<typeof datePickerProps>;

package/dist/components/date-picker/src/props.js

@@ -0,0 +1,21 @@
+import "../../time-picker/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as r, definePropType as t } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { timePickerDefaultProps as o } from "../../time-picker/src/common/props.js";
+const s = r({
+  ...o,
+  /**
+   * @description type of the picker
+   */
+  type: {
+    type: t(String),
+    default: "date"
+  }
+});
+export {
+  s as datePickerProps
+};

package/dist/components/date-picker-panel/index.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vue';
+import _DatePickerPanel from './src/date-picker-panel';
+export declare const EpDatePickerPanel: typeof _DatePickerPanel & Plugin;
+export default EpDatePickerPanel;
+export * from './src/constants';
+export * from './src/props/date-picker-panel';
+export * from './src/types';
+export type { DatePickerPanelInstance } from './src/instance';

package/dist/components/date-picker-panel/index.js

@@ -0,0 +1,11 @@
+import { withInstall as e } from "../../utils/with-install.js";
+import r from "./src/date-picker-panel.js";
+import { datePickerPanelProps as P } from "./src/props/date-picker-panel.js";
+const o = e(
+  r,
+  "ep-date-picker-panel"
+);
+export {
+  o as EpDatePickerPanel,
+  P as datePickerPanelProps
+};

package/dist/components/date-picker-panel/src/composables/use-basic-date-table.d.ts

@@ -0,0 +1,187 @@
+import dayjs from 'dayjs';
+import type { SetupContext } from 'vue';
+import type { Dayjs } from 'dayjs';
+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<DateCell[][] | {
+        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?: Date | 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" | "next-month" | "prev-month") | undefined;
+    }[][]>;
+    tbodyRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    currentCellRef: import("vue").Ref<HTMLElement | undefined, 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[]>;
+    tableLabel: import("vue").ComputedRef<string>;
+    weekHeaderClass: string;
+    getCellClasses: (cell: DateCell) => string;
+    getRowKls: (cell: DateCell) => (string | {
+        current: boolean;
+    })[];
+    t: import("@element-plus/hooks").Translator;
+};

package/dist/components/date-picker-panel/src/composables/use-basic-date-table.js

@@ -0,0 +1,195 @@
+import { ref as b, computed as m, unref as r, watch as Z, nextTick as p } from "vue";
+import j from "dayjs";
+import { flatten as tt } from "lodash-unified";
+import { useNamespace as et } from "../../../../hooks/use-namespace/index.js";
+import { castArray as v } from "../../../../utils/arrays.js";
+import "@vueuse/core";
+import { isArray as at } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { useLocale as A } from "../../../../hooks/use-locale/index.js";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+import { buildPickerTable as nt } from "../utils.js";
+const C = (a = "") => ["normal", "today"].includes(a), Mt = (a, l) => {
+  const { lang: g } = A(), h = b(), k = b(), w = b(), M = b(), x = b([[], [], [], [], [], []]);
+  let D = !1;
+  const o = a.date.$locale().weekStart || 7, u = a.date.locale("en").localeData().weekdaysShort().map((t) => t.toLowerCase()), N = m(() => o > 3 ? 7 - o : -o), E = m(() => {
+    const t = a.date.startOf("month");
+    return t.subtract(t.day() || 7, "day");
+  }), L = m(() => u.concat(u).slice(
+    o,
+    o + 7
+  )), S = m(() => tt(r(O)).some((t) => t.isCurrent)), R = m(() => {
+    const t = a.date.startOf("month"), e = t.day() || 7, n = t.daysInMonth(), s = t.subtract(1, "month").daysInMonth();
+    return {
+      startOfMonthDay: e,
+      dateCountOfMonth: n,
+      dateCountOfLastMonth: s
+    };
+  }), F = m(() => a.selectionMode === "dates" ? v(a.parsedValue) : []), K = (t, { count: e, rowIndex: n, columnIndex: s }) => {
+    const { startOfMonthDay: d, dateCountOfMonth: c, dateCountOfLastMonth: f } = r(R), y = r(N);
+    if (n >= 0 && n <= 1) {
+      const i = d + y < 0 ? 7 + d + y : d + y;
+      if (s + n * 7 >= i)
+        return t.text = e, !0;
+      t.text = f - (i - s % 7) + 1 + n * 7, t.type = "prev-month";
+    } else
+      return e <= c ? t.text = e : (t.text = e - c, t.type = "next-month"), !0;
+    return !1;
+  }, _ = (t, { columnIndex: e, rowIndex: n }, s) => {
+    const { disabledDate: d, cellClassName: c } = a, f = r(F), y = K(t, { count: s, rowIndex: n, columnIndex: e }), i = t.dayjs.toDate();
+    return t.selected = f.find((Y) => Y.isSame(t.dayjs, "day")), t.isSelected = !!t.selected, t.isCurrent = P(t), t.disabled = d == null ? void 0 : d(i), t.customClass = c == null ? void 0 : c(i), y;
+  }, $ = (t) => {
+    if (a.selectionMode === "week") {
+      const [e, n] = a.showWeekNumber ? [1, 7] : [0, 6], s = I(t[e + 1]);
+      t[e].inRange = s, t[e].start = s, t[n].inRange = s, t[n].end = s;
+    }
+  }, O = m(() => {
+    const { minDate: t, maxDate: e, rangeState: n, showWeekNumber: s } = a, d = r(N), c = r(x), f = "day";
+    let y = 1;
+    if (nt({ row: 6, column: 7 }, c, {
+      startDate: t,
+      columnIndexOffset: s ? 1 : 0,
+      nextEndDate: n.endDate || e || n.selecting && t || null,
+      now: j().locale(r(g)).startOf(f),
+      unit: f,
+      relativeDateGetter: (i) => r(E).add(i - d, f),
+      setCellMetadata: (...i) => {
+        _(...i, y) && (y += 1);
+      },
+      setRowMetadata: $
+    }), s)
+      for (let i = 0; i < 6; i++)
+        c[i][1].dayjs && (c[i][0] = {
+          type: "week",
+          text: c[i][1].dayjs.week()
+        });
+    return c;
+  });
+  Z(
+    () => a.date,
+    async () => {
+      var t;
+      (t = r(h)) != null && t.contains(document.activeElement) && (await p(), await V());
+    }
+  );
+  const V = async () => {
+    var t;
+    return (t = r(k)) == null ? void 0 : t.focus();
+  }, P = (t) => a.selectionMode === "date" && C(t.type) && B(t, a.parsedValue), B = (t, e) => e ? j(e).locale(r(g)).isSame(a.date.date(Number(t.text)), "day") : !1, T = (t, e) => {
+    const n = r(R).startOfMonthDay, s = r(N), d = n + s < 0 ? 7 + n + s : n + s, c = t * 7 + (e - (a.showWeekNumber ? 1 : 0));
+    return a.date.startOf("month").subtract(d, "day").add(c, "day");
+  }, U = (t) => {
+    var d;
+    if (!a.rangeState.selecting) return;
+    let e = t.target;
+    if (e.tagName === "SPAN" && (e = (d = e.parentNode) == null ? void 0 : d.parentNode), e.tagName === "DIV" && (e = e.parentNode), e.tagName !== "TD") return;
+    const n = e.parentNode.rowIndex - 1, s = e.cellIndex;
+    r(O)[n][s].disabled || (n !== r(w) || s !== r(M)) && (w.value = n, M.value = s, l("changerange", {
+      selecting: !0,
+      endDate: T(n, s)
+    }));
+  }, G = (t) => !r(S) && (t == null ? void 0 : t.text) === 1 && C(t.type) || t.isCurrent, H = (t) => {
+    D || r(S) || a.selectionMode !== "date" || W(t, !0);
+  }, q = (t) => {
+    t.target.closest("td") && (D = !0);
+  }, z = (t) => {
+    t.target.closest("td") && (D = !1);
+  }, J = (t) => {
+    !a.rangeState.selecting || !a.minDate ? (l("pick", { minDate: t, maxDate: null }), l("select", !0)) : (t >= a.minDate ? l("pick", { minDate: a.minDate, maxDate: t }) : l("pick", { minDate: t, maxDate: a.minDate }), l("select", !1));
+  }, Q = (t) => {
+    const e = t.week(), n = `${t.year()}w${e}`;
+    l("pick", {
+      year: t.year(),
+      week: e,
+      value: n,
+      date: t.startOf("week")
+    });
+  }, X = (t, e) => {
+    const n = e ? v(a.parsedValue).filter(
+      (s) => (s == null ? void 0 : s.valueOf()) !== t.valueOf()
+    ) : v(a.parsedValue).concat([t]);
+    l("pick", n);
+  }, W = (t, e = !1) => {
+    if (a.disabled) return;
+    const n = t.target.closest("td");
+    if (!n) return;
+    const s = n.parentNode.rowIndex - 1, d = n.cellIndex, c = r(O)[s][d];
+    if (c.disabled || c.type === "week") return;
+    const f = T(s, d);
+    switch (a.selectionMode) {
+      case "range": {
+        J(f);
+        break;
+      }
+      case "date": {
+        l("pick", f, e);
+        break;
+      }
+      case "week": {
+        Q(f);
+        break;
+      }
+      case "dates": {
+        X(f, !!c.selected);
+        break;
+      }
+    }
+  }, I = (t) => {
+    if (a.selectionMode !== "week") return !1;
+    let e = a.date.startOf("day");
+    if (t.type === "prev-month" && (e = e.subtract(1, "month")), t.type === "next-month" && (e = e.add(1, "month")), e = e.date(Number.parseInt(t.text, 10)), a.parsedValue && !at(a.parsedValue)) {
+      const n = (a.parsedValue.day() - o + 7) % 7 - 1;
+      return a.parsedValue.subtract(n, "day").isSame(e, "day");
+    }
+    return !1;
+  };
+  return {
+    WEEKS: L,
+    rows: O,
+    tbodyRef: h,
+    currentCellRef: k,
+    // cellMatchesDate,
+    // getDateOfCell,
+    focus: V,
+    isCurrent: P,
+    isWeekActive: I,
+    isSelectedCell: G,
+    handlePickDate: W,
+    handleMouseUp: z,
+    handleMouseDown: q,
+    handleMouseMove: U,
+    handleFocus: H
+  };
+}, Ot = (a, {
+  isCurrent: l,
+  isWeekActive: g
+}) => {
+  const h = et("date-table"), { t: k } = A(), w = m(() => [
+    h.b(),
+    h.is("week-mode", a.selectionMode === "week" && !a.disabled)
+  ]), M = m(() => k("el.datepicker.dateTablePrompt")), x = (o) => {
+    const u = [];
+    return C(o.type) && !o.disabled ? (u.push("available"), o.type === "today" && u.push("today")) : u.push(o.type), l(o) && u.push("current"), o.inRange && (C(o.type) || a.selectionMode === "week") && (u.push("in-range"), o.start && u.push("start-date"), o.end && u.push("end-date")), (o.disabled || a.disabled) && u.push("disabled"), o.selected && u.push("selected"), o.customClass && u.push(o.customClass), u.join(" ");
+  }, D = (o) => [
+    h.e("row"),
+    { current: g(o) }
+  ];
+  return {
+    tableKls: w,
+    tableLabel: M,
+    weekHeaderClass: h.e("week-header"),
+    getCellClasses: x,
+    getRowKls: D,
+    t: k
+  };
+};
+export {
+  Mt as useBasicDateTable,
+  Ot as useBasicDateTableDOM
+};

package/dist/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>;
+};