ep-craft 0.1.25 → 0.1.26

package/dist/components/date-picker-panel/src/composables/use-month-range-header.js

@@ -0,0 +1,41 @@
+import { computed as a } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useLocale as s } 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";
+const j = ({
+  unlinkPanels: u,
+  leftDate: r,
+  rightDate: e
+}) => {
+  const { t: o } = s(), v = () => {
+    r.value = r.value.subtract(1, "year"), u.value || (e.value = e.value.subtract(1, "year"));
+  }, l = () => {
+    u.value || (r.value = r.value.add(1, "year")), e.value = e.value.add(1, "year");
+  }, c = () => {
+    r.value = r.value.add(1, "year");
+  }, p = () => {
+    e.value = e.value.subtract(1, "year");
+  }, m = a(() => `${r.value.year()} ${o("el.datepicker.year")}`), t = a(() => `${e.value.year()} ${o("el.datepicker.year")}`), y = a(() => r.value.year()), n = a(() => e.value.year() === r.value.year() ? r.value.year() + 1 : e.value.year());
+  return {
+    leftPrevYear: v,
+    rightNextYear: l,
+    leftNextYear: c,
+    rightPrevYear: p,
+    leftLabel: m,
+    rightLabel: t,
+    leftYear: y,
+    rightYear: n
+  };
+};
+export {
+  j as useMonthRangeHeader
+};

package/dist/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, CurrentView>;
+    rightCurrentView: Ref<CurrentView, CurrentView>;
+    leftCurrentViewRef: Ref<CurrentViewRef | undefined, CurrentViewRef | undefined>;
+    rightCurrentViewRef: Ref<CurrentViewRef | undefined, 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 {};

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

@@ -0,0 +1,86 @@
+import { ref as f, inject as _, computed as o, nextTick as b } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useLocale as j } 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 "../../../time-picker/index.js";
+import { getValidDateOfYear as x, getValidDateOfMonth as K } from "../utils.js";
+import { PICKER_BASE_INJECTION_KEY as N } from "../../../time-picker/src/constants.js";
+const et = (h, L, i, l) => {
+  const c = f("date"), m = f(), u = f("date"), d = f(), $ = _(N), { disabledDate: v } = $.props, { t: C, lang: p } = j(), y = o(() => i.value.year()), M = o(() => i.value.month()), P = o(() => l.value.year()), V = o(() => l.value.month());
+  function g(t, n) {
+    const a = C("el.datepicker.year");
+    if (t.value === "year") {
+      const e = Math.floor(n.value / 10) * 10;
+      return a ? `${e} ${a} - ${e + 9} ${a}` : `${e} - ${e + 9}`;
+    }
+    return `${n.value} ${a}`;
+  }
+  function k(t) {
+    t == null || t.focus();
+  }
+  async function w(t, n) {
+    if (h.disabled) return;
+    const a = t === "left" ? c : u, e = t === "left" ? m : d;
+    a.value = n, await b(), k(e.value);
+  }
+  async function s(t, n, a) {
+    if (h.disabled) return;
+    const e = n === "left", r = e ? i : l, E = e ? l : i, B = e ? c : u, I = e ? m : d;
+    if (t === "year") {
+      const O = r.value.year(a);
+      r.value = x(O, p.value, v);
+    }
+    t === "month" && (r.value = K(
+      r.value,
+      r.value.year(),
+      a,
+      p.value,
+      v
+    )), h.unlinkPanels || (E.value = n === "left" ? r.value.add(1, "month") : r.value.subtract(1, "month")), B.value = t === "year" ? "month" : "date", await b(), k(I.value), Y(t);
+  }
+  function Y(t) {
+    L(
+      "panel-change",
+      [i.value.toDate(), l.value.toDate()],
+      t
+    );
+  }
+  function R(t, n, a) {
+    const e = a ? "add" : "subtract";
+    return t === "year" ? n[e](10, "year") : n[e](1, "year");
+  }
+  return {
+    leftCurrentView: c,
+    rightCurrentView: u,
+    leftCurrentViewRef: m,
+    rightCurrentViewRef: d,
+    leftYear: y,
+    rightYear: P,
+    leftMonth: M,
+    rightMonth: V,
+    leftYearLabel: o(() => g(c, y)),
+    rightYearLabel: o(
+      () => g(u, P)
+    ),
+    showLeftPicker: (t) => w("left", t),
+    showRightPicker: (t) => w("right", t),
+    handleLeftYearPick: (t) => s("year", "left", t),
+    handleRightYearPick: (t) => s("year", "right", t),
+    handleLeftMonthPick: (t) => s("month", "left", t),
+    handleRightMonthPick: (t) => s("month", "right", t),
+    handlePanelChange: Y,
+    adjustDateByView: R
+  };
+};
+export {
+  et as usePanelDateRange
+};

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

@@ -0,0 +1,209 @@
+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, dayjs.Dayjs | undefined>;
+    maxDate: Ref<dayjs.Dayjs | undefined, 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;
+    }, RangeState | {
+        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, 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/hooks").Translator;
+};
+export {};

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

@@ -0,0 +1,102 @@
+import { getCurrentInstance as q, inject as w, ref as g, watch as v, unref as n } from "vue";
+import k from "dayjs";
+import { isArray as D } from "@vue/shared";
+import { isEqual as A } from "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useNamespace as J } from "../../../../hooks/use-namespace/index.js";
+import { useLocale as L } 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 { getDefaultValue as Y, isValidRange as z } from "../utils.js";
+import { ROOT_PICKER_INJECTION_KEY as B } from "../constants.js";
+import { useShortcut as F } from "./use-shortcut.js";
+const st = (m, {
+  defaultValue: h,
+  defaultTime: C,
+  leftDate: p,
+  rightDate: N,
+  step: O,
+  unit: R,
+  sortDates: E
+}) => {
+  const { emit: _ } = q(), { pickerNs: I } = w(B), P = J("date-range-picker"), { t: b, lang: f } = L(), x = F(f), o = g(), r = g(), s = g({
+    endDate: null,
+    selecting: !1
+  }), T = (t) => {
+    s.value = t;
+  }, j = (t = !1) => {
+    const e = n(o), i = n(r);
+    z([e, i]) && _("pick", [e, i], t);
+  }, y = (t) => {
+    s.value.selecting = t, t || (s.value.endDate = null);
+  }, u = (t) => {
+    if (D(t) && t.length === 2) {
+      const [e, i] = t;
+      o.value = e, p.value = e, r.value = i, E(n(o), n(r));
+    } else
+      S();
+  }, S = () => {
+    let [t, e] = Y(n(h), {
+      lang: n(f),
+      step: O,
+      unit: R,
+      unlinkPanels: m.unlinkPanels
+    });
+    const i = (a) => a.diff(a.startOf("d"), "ms"), l = n(C);
+    if (l) {
+      let a = 0, d = 0;
+      if (D(l)) {
+        const [c, K] = l.map(k);
+        a = i(c), d = i(K);
+      } else {
+        const c = i(k(l));
+        a = c, d = c;
+      }
+      t = t.startOf("d").add(a, "ms"), e = e.startOf("d").add(d, "ms");
+    }
+    o.value = void 0, r.value = void 0, p.value = t, N.value = e;
+  };
+  return v(
+    h,
+    (t) => {
+      t && S();
+    },
+    { immediate: !0 }
+  ), v(
+    () => m.parsedValue,
+    (t) => {
+      (!(t != null && t.length) || !A(t, [o.value, r.value])) && u(t);
+    },
+    {
+      immediate: !0
+    }
+  ), v(
+    () => m.visible,
+    () => {
+      m.visible && u(m.parsedValue);
+    },
+    { immediate: !0 }
+  ), {
+    minDate: o,
+    maxDate: r,
+    rangeState: s,
+    lang: f,
+    ppNs: I,
+    drpNs: P,
+    handleChangeRange: T,
+    handleRangeConfirm: j,
+    handleShortcutClick: x,
+    onSelect: y,
+    parseValue: u,
+    t: b
+  };
+};
+export {
+  st as useRangePicker
+};

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

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

@@ -0,0 +1,27 @@
+import { getCurrentInstance as c, useAttrs as s, useSlots as u } from "vue";
+import l from "dayjs";
+import { isFunction as a } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+const d = (e) => {
+  const { emit: r } = c(), i = s(), n = u();
+  return (t) => {
+    const o = a(t.value) ? t.value() : t.value;
+    if (o) {
+      r("pick", [
+        l(o[0]).locale(e.value),
+        l(o[1]).locale(e.value)
+      ]);
+      return;
+    }
+    t.onClick && t.onClick({
+      attrs: i,
+      slots: n,
+      emit: r
+    });
+  };
+};
+export {
+  d as useShortcut
+};

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

package/dist/components/date-picker-panel/src/composables/use-year-range-header.js

@@ -0,0 +1,35 @@
+import { computed as t } from "vue";
+const Y = ({
+  unlinkPanels: u,
+  leftDate: a,
+  rightDate: r
+}) => {
+  const o = () => {
+    a.value = a.value.subtract(10, "year"), u.value || (r.value = r.value.subtract(10, "year"));
+  }, l = () => {
+    u.value || (a.value = a.value.add(10, "year")), r.value = r.value.add(10, "year");
+  }, v = () => {
+    a.value = a.value.add(10, "year");
+  }, n = () => {
+    r.value = r.value.subtract(10, "year");
+  }, c = t(() => {
+    const e = Math.floor(a.value.year() / 10) * 10;
+    return `${e}-${e + 9}`;
+  }), s = t(() => {
+    const e = Math.floor(r.value.year() / 10) * 10;
+    return `${e}-${e + 9}`;
+  }), d = t(() => Math.floor(a.value.year() / 10) * 10 + 9), y = t(() => Math.floor(r.value.year() / 10) * 10);
+  return {
+    leftPrevYear: o,
+    rightNextYear: l,
+    leftNextYear: v,
+    rightPrevYear: n,
+    leftLabel: c,
+    rightLabel: s,
+    leftYear: d,
+    rightYear: y
+  };
+};
+export {
+  Y as useYearRangeHeader
+};

package/dist/components/date-picker-panel/src/constants.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey, SetupContext } from 'vue';
+import type { UseNamespaceReturn } from '@element-plus/hooks';
+interface DatePickerContext {
+    slots: SetupContext['slots'];
+    pickerNs: UseNamespaceReturn;
+}
+export declare const ROOT_PICKER_INJECTION_KEY: InjectionKey<DatePickerContext>;
+export declare const ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = "ElIsDefaultFormat";
+export {};

package/dist/components/date-picker-panel/src/constants.js

@@ -0,0 +1,5 @@
+const _ = Symbol("rootPickerContextKey"), o = "ElIsDefaultFormat";
+export {
+  _ as ROOT_PICKER_INJECTION_KEY,
+  o as ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY
+};

package/dist/components/date-picker-panel/src/date-picker-com/basic-cell-render.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly cell: {
+        readonly type: import("vue").PropType<import("../types").DateCell>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly cell: {
+        readonly type: import("vue").PropType<import("../types").DateCell>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/date-picker-panel/src/date-picker-com/basic-cell-render.js

@@ -0,0 +1,39 @@
+import { defineComponent as m, inject as i, renderSlot as s, createVNode as e } from "vue";
+import { useNamespace as a } from "../../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+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 { ROOT_PICKER_INJECTION_KEY as n } from "../constants.js";
+import { basicCellProps as l } from "../props/basic-cell.js";
+const D = /* @__PURE__ */ m({
+  name: "ElDatePickerCell",
+  props: l,
+  setup(o) {
+    const r = a("date-table-cell"), {
+      slots: p
+    } = i(n);
+    return () => {
+      const {
+        cell: t
+      } = o;
+      return s(p, "default", {
+        ...t
+      }, () => [e("div", {
+        class: r.b()
+      }, [e("span", {
+        class: r.e("text")
+      }, [(t == null ? void 0 : t.renderText) ?? (t == null ? void 0 : t.text)])])]);
+    };
+  }
+});
+export {
+  D as default
+};