@ironsource/shared-ui 2.1.6-test.2 → 2.1.6-test.4

package/components/datePicker/v4/index.d.ts

@@ -0,0 +1,184 @@
+declare const DatePickerTypes: () => ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            testId: string;
+            modelValue: string | Date;
+            placeholder: string;
+            uniqueId: string | number;
+            allowFutureDates: boolean;
+            dateFormat: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            modelValue: {
+                type: import("vue").PropType<string | Date>;
+                default: any;
+            };
+            placeholder: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            uniqueId: {
+                type: import("vue").PropType<string | number>;
+                default: number;
+            };
+            allowFutureDates: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            dateFormat: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: (val: string | Date) => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "testId" | "modelValue" | "placeholder" | "uniqueId" | "allowFutureDates" | "dateFormat">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: "update:modelValue", val: string | Date) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            modelValue: {
+                type: import("vue").PropType<string | Date>;
+                default: any;
+            };
+            placeholder: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            uniqueId: {
+                type: import("vue").PropType<string | number>;
+                default: number;
+            };
+            allowFutureDates: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            dateFormat: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: (val: string | Date) => any;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: string | Date) => void;
+        }, string, {
+            testId: string;
+            modelValue: string | Date;
+            placeholder: string;
+            uniqueId: string | number;
+            allowFutureDates: boolean;
+            dateFormat: string;
+        }, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        testId: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        modelValue: {
+            type: import("vue").PropType<string | Date>;
+            default: any;
+        };
+        placeholder: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        uniqueId: {
+            type: import("vue").PropType<string | number>;
+            default: number;
+        };
+        allowFutureDates: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        dateFormat: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: (val: string | Date) => any;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    testId: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | Date>;
+        default: any;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    uniqueId: {
+        type: import("vue").PropType<string | number>;
+        default: number;
+    };
+    allowFutureDates: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    dateFormat: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>> & {
+    "onUpdate:modelValue"?: (val: string | Date) => any;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (val: string | Date) => void;
+}, string, {
+    testId: string;
+    modelValue: string | Date;
+    placeholder: string;
+    uniqueId: string | number;
+    allowFutureDates: boolean;
+    dateFormat: string;
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {
+            formattedDate: any;
+        }): any;
+    };
+}))[];
+export { default as DatePicker } from './DatePickerV4.vue';
+export { DatePickerTypes };

package/components/dateRange/common/CalendarMonth.common.d.ts

@@ -0,0 +1,17 @@
+export declare const calendarMonthCommon: (props: any, emit: any) => {
+    isEndDay: (day: any) => boolean;
+    isStartDay: (day: any) => boolean;
+    updateSelection: () => void;
+    refreshDisabledDays: () => void;
+    getMinDateInMonth: () => Date;
+    getLastDayInRangeForMonth: (date: any, month: any) => any;
+    getFirstDayInRangeForMonth: (date: any, month: any) => any;
+    isMonthInRange: () => boolean;
+    navigate: (navigation: any) => void;
+    selectDay: (day: any) => void;
+    monthName: import("vue").ComputedRef<string>;
+    dayNames: string[];
+    selectedDays: import("vue").Ref<any[]>;
+    selectedDaysMap: import("vue").Ref<{}>;
+    inBetweenMap: import("vue").Ref<{}>;
+};

package/components/dateRange/common/CalendarMonth.common.js

@@ -0,0 +1,131 @@
+import g from "./DateServices.common.js";
+import { ref as d, computed as A, watch as D, onMounted as x } from "vue";
+import { isBefore as C, isAfter as J, isSameDay as F } from "date-fns";
+const j = (t, M) => {
+  const E = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ], b = ["S", "M", "T", "W", "T", "F", "S"], l = d([]), i = d({}), s = d({}), Y = A(() => E[t.month]), w = (e) => {
+    e.value !== 0 && M("selectionChanged", e, t.month, t.year);
+  }, I = (e) => {
+    M("navigation", e);
+  }, S = () => {
+    if (!t.range.fromStart || !t.range.toEnd)
+      return !1;
+    const e = t.range.fromStart.getMonth(), n = t.range.fromStart.getFullYear(), r = t.range.toEnd.getMonth(), a = t.range.toEnd.getFullYear();
+    return t.year < n || t.year > a ? !1 : !(t.year === n && t.month < e || t.year === a && t.month > r);
+  }, f = (e, n) => e.getMonth() < n.month && e.getFullYear() === n.year || e.getFullYear() < n.year ? 1 : e.getMonth() === n.month && e.getFullYear() === n.year ? e.getDate() : g.daysInMonth(n.month, n.year), y = (e, n) => e.getMonth() > n.month && e.getFullYear() === n.year || e.getFullYear() > n.year ? g.daysInMonth(n.month, n.year) : e.getMonth() === n.month && e.getFullYear() === n.year ? e.getDate() : 1, v = () => {
+    if (t.allowedDays) {
+      const e = g.getCurrentTimeUTC();
+      e.setDate(e.getDate() - t.allowedDays + 1);
+      let n = e;
+      switch (t.type) {
+        case "week":
+          n = g.getFirstDayOfWeek(e);
+          break;
+        case "month":
+          n.setDate(1);
+          break;
+      }
+      return n.setHours(0, 0, 0, 0), n;
+    }
+    return null;
+  }, m = () => {
+    const e = v(), n = t.maxAllowedDate;
+    Object.keys(t.days).forEach((r) => {
+      const a = t.days[r];
+      e && C(a.date, e) || n && J(a.date, n) ? a.disabled = !0 : delete a.disabled;
+    });
+  }, u = (e, n, r, a) => {
+    t.year === e.getFullYear() && t.month === e.getMonth() && n >= r && n <= a && (i.value[n] = !0);
+  }, c = () => {
+    for (let e = 0; e < l.value.length; e++) {
+      const n = l.value[e];
+      delete i.value[n.value], delete s.value[n.value];
+    }
+    if (l.value = [], S()) {
+      const e = { month: t.month, year: t.year }, n = f(
+        t.range.fromStart,
+        e
+      ), r = y(
+        t.range.fromEnd,
+        e
+      ), a = f(
+        t.range.toStart,
+        e
+      ), h = y(
+        t.range.toEnd,
+        e
+      );
+      for (let o = n; o <= h; o++)
+        s.value[o] = !0, u(
+          t.range.fromStart,
+          o,
+          n,
+          r
+        ), u(
+          t.range.fromEnd,
+          o,
+          n,
+          r
+        ), u(
+          t.range.toStart,
+          o,
+          a,
+          h
+        ), u(
+          t.range.toEnd,
+          o,
+          a,
+          h
+        ), l.value.push(t.days[o]);
+    }
+  }, T = (e) => e.value === 0 ? !1 : F(e.date, t.range.fromStart), k = (e) => e.value === 0 ? !1 : F(e.date, t.range.toEnd);
+  return D(
+    () => t.month,
+    () => {
+      c();
+    }
+  ), D(
+    () => t.range,
+    (e, n) => {
+      e && e !== n && c();
+    }
+  ), D(
+    () => t.maxAllowedDate,
+    () => {
+      m();
+    }
+  ), x(() => {
+    m(), c();
+  }), {
+    isEndDay: k,
+    isStartDay: T,
+    updateSelection: c,
+    refreshDisabledDays: m,
+    getMinDateInMonth: v,
+    getLastDayInRangeForMonth: y,
+    getFirstDayInRangeForMonth: f,
+    isMonthInRange: S,
+    navigate: I,
+    selectDay: w,
+    monthName: Y,
+    dayNames: b,
+    selectedDays: l,
+    selectedDaysMap: i,
+    inBetweenMap: s
+  };
+};
+export {
+  j as calendarMonthCommon
+};

package/components/dateRange/common/DateRange.common.d.ts

@@ -0,0 +1,47 @@
+export declare const dateRangeCommon: (props: any, emit: any) => {
+    datePicker: import("vue").Ref<HTMLDivElement>;
+    datePickerId: import("vue").ComputedRef<string>;
+    getMaxAllowedDate: import("vue").ComputedRef<Date>;
+    selectedPresetName: import("vue").ComputedRef<any>;
+    selectedPreset: import("vue").Ref<{}>;
+    displayError: import("vue").Ref<boolean>;
+    rangeType: any;
+    selectedRange: any;
+    placement: import("vue").Ref<string>;
+    currentDate: any;
+    error: any;
+    presets: import("vue").Ref<any[]>;
+    isOpen: import("vue").Ref<boolean>;
+    popup: any;
+    selectionStart: import("vue").Ref<{
+        started: boolean;
+        date: any;
+    }>;
+    initialized: import("vue").Ref<boolean>;
+    textDates: import("vue").Ref<{
+        from: any;
+        to: any;
+    }>;
+    currentMonths: import("vue").Ref<{}>;
+    displayedMonthsKeys: import("vue").Ref<any[]>;
+    initMonths: () => void;
+    changeType: (type: any, resetDate?: any) => void;
+    presetChanged: (selectedObj: any) => void;
+    initRange: (newValue: any, selectionNotCompleted?: boolean) => boolean;
+    setCurrentDate: () => void;
+    apply: () => void;
+    getNavigation: (isFirst: any, isLast: any) => "previous" | "next";
+    navigationCallback: (direction: any) => void;
+    getSelectedRangeByType: (dateRange: {
+        from: Date;
+        to: Date;
+    }) => any;
+    compareDates: (dateA: Date, dateB: Date) => boolean;
+    determinePreset: (range: any) => void;
+    selectionChanged: (day: any, month: any, year: any) => void;
+    checkPlacement: () => "left" | "right";
+    toggle: (dismiss?: boolean) => void;
+    closeDatePicker: () => void;
+    isCompact: import("vue").ComputedRef<any>;
+    init: () => void;
+};

package/components/dateRange/common/DateRange.common.js

@@ -0,0 +1,265 @@
+import { onClickOutside as ie } from "@vueuse/core";
+import { useToggle as fe } from "../../../composables/useToggle.js";
+import { ref as r, computed as b, onMounted as ce, onBeforeMount as de, onUnmounted as ve, watch as Q } from "vue";
+import { min as me, addDays as ge, format as X } from "date-fns";
+import { presetsList as he, formatError as De, mandatoryValuesError as Me, navigatePrev as Z, navigateNext as V } from "./consts.common.js";
+import m from "./DateServices.common.js";
+const Te = (o, y) => {
+  const N = r(null), c = r({ started: !1, date: null }), x = r(!1), _ = 2, S = r({ from: null, to: null }), s = r({}), g = r([]), k = r(null), f = r({}), T = r({}), w = r(!1), P = r(null), u = r(null), j = r("left"), p = r(null), O = r(null), E = r([]), K = r(null), [h] = fe({ initialValue: !1 }), q = r(null);
+  ie(q, () => {
+    h.value = !1;
+  });
+  const L = (e, t) => {
+    const a = {
+      weeks: [],
+      days: {},
+      month: e,
+      year: t
+    };
+    let n, l;
+    const d = new Date(t, e, 1).getDay();
+    let v = 1;
+    const i = /* @__PURE__ */ new Date();
+    i.setHours(0, 0, 0, 0);
+    const se = m.daysInMonth(e, t);
+    for (let I = 0; I < 6; I++) {
+      l = [];
+      for (let H = 0; H < 7; H++)
+        n = {}, I === 0 && d > 0 && H < d && (n.value = 0), v > se && (n.value = 0), !n.value && n.value !== 0 && (n.value = v, v += 1, a.days[n.value] = n, n.date = new Date(t, e, n.value), i < n.date ? n.isFuture = !0 : n.date.getTime() === i.getTime() && (n.isToday = !0, o.includeToday || (n.disabled = !0))), l.push(n);
+      a.weeks.push(l);
+    }
+    return a;
+  }, C = () => {
+    let e = m.getCurrentTimeUTC();
+    if (u.value && u.value.toEnd ? e = u.value.toEnd : o.range && o.range.to && (e = o.range.to), !s.value[`${e.getFullYear().toString()}_${e.getMonth().toString()}`]) {
+      s.value = {}, g.value = [];
+      for (let t = 0; t < _; t++) {
+        const a = new Date(e);
+        a.setDate(1), a.setMonth(e.getMonth() - t);
+        const n = `${a.getFullYear().toString()}_${a.getMonth().toString()}`;
+        s.value[n] = {
+          parsedMonth: L(
+            a.getMonth(),
+            a.getFullYear()
+          ),
+          order: t
+        }, g.value.unshift(n);
+      }
+    }
+  }, z = (e, t) => {
+    P.value = e;
+    let a = e;
+    e === "date" && (a = o.datePresetList), E.value = he[a], t && (u.value = {
+      fromStart: null,
+      fromEnd: null,
+      toStart: null,
+      toEnd: null
+    }, S.value.from = "", S.value.to = "", c.value = { started: !1, date: null }, f.value = "custom"), y("rangeTypeChanged", P.value);
+  }, ee = (e) => {
+    f.value = e.id, D(k.value[e.id].dates()), C();
+  }, D = (e, t = !1) => {
+    let a = e;
+    return (!e || !e.from && !e.to) && (a = k.value[E.value[0]]), o.maxDaysInRange && (K.value = t ? ge(a.from, o.maxDaysInRange) : null), w.value = !1, !a.from || !a.to || !(a.from instanceof Date) || !(a.to instanceof Date) ? (O.value = De, w.value = !0, !1) : a.from > a.to ? (O.value = `"From" date can't be bigger than "To" date`, w.value = !0, !1) : (u.value = R(a), S.value.from = X(
+      u.value.fromStart,
+      o.dateFormat
+    ), S.value.to = X(u.value.toEnd, o.dateFormat), !0);
+  }, F = () => {
+    f.value === "custom" ? p.value = m.getDateRangeString(u.value) : p.value = J.value, y("currentDateChanged", p.value);
+  }, te = () => {
+    if (u.value.fromStart == null || u.value.toEnd == null) {
+      w.value = !0, O.value = Me;
+      return;
+    }
+    const e = m.getCurrentTimeUTC();
+    u.value.toEnd > e && (u.value.toEnd = e), F(), T.value = f.value, y("rangeChanged", {
+      from: u.value.fromStart,
+      to: u.value.toEnd,
+      preset: T.value
+    }), W(!1);
+  }, ae = (e, t) => e ? Z : t ? V : null, ne = (e) => {
+    let t = null, a = null;
+    const n = _ - 1;
+    let l = "", M = null, d = null;
+    switch (e) {
+      case V:
+        Object.keys(s.value).forEach((v) => {
+          const i = s.value[v];
+          i.order === 0 && (M = i), i.order === n ? (g.value.splice(
+            g.value.indexOf(v),
+            1
+          ), delete s.value[v]) : i.order += 1;
+        }), t = M.parsedMonth.month + 1, a = M.parsedMonth.year, t > 11 && (t = 0, a += 1), l = `${a.toString()}_${t.toString()}`, s.value[l] = {
+          parsedMonth: L(t, a),
+          order: 0
+        }, g.value.push(l);
+        break;
+      case Z:
+        Object.keys(s.value).forEach((v) => {
+          const i = s.value[v];
+          i.order === n && (d = i), i.order === 0 ? (g.value.splice(
+            g.value.indexOf(v),
+            1
+          ), delete s.value[v]) : i.order -= 1;
+        }), t = d.parsedMonth.month - 1, a = d.parsedMonth.year, t < 0 && (t = 11, a -= 1), l = `${a.toString()}_${t.toString()}`, s.value[l] = {
+          parsedMonth: L(t, a),
+          order: n
+        }, g.value.unshift(l);
+        break;
+    }
+  }, R = (e) => {
+    let t;
+    switch (P.value) {
+      case "week":
+        t = {
+          fromStart: m.getFirstDayOfWeek(e.from),
+          fromEnd: m.getLastDayOfWeek(e.from),
+          toStart: m.getFirstDayOfWeek(e.to),
+          toEnd: m.getLastDayOfWeek(e.to)
+        };
+        break;
+      case "month":
+        t = {
+          fromStart: new Date(
+            e.from.getFullYear(),
+            e.from.getMonth(),
+            1
+          ),
+          fromEnd: m.getLastDayOfMonth(e.from),
+          toStart: new Date(
+            e.to.getFullYear(),
+            e.to.getMonth(),
+            1
+          ),
+          toEnd: m.getLastDayOfMonth(e.to)
+        };
+        break;
+      case "date":
+      default:
+        t = {
+          fromStart: e.from,
+          fromEnd: e.from,
+          toStart: e.to,
+          toEnd: e.to
+        };
+        break;
+    }
+    return t;
+  }, U = (e, t) => e.getUTCFullYear() === t.getUTCFullYear() && e.getUTCMonth() === t.getUTCMonth() && e.getUTCDate() === t.getUTCDate(), $ = (e) => {
+    let t = !1;
+    const a = {
+      from: new Date(e.from),
+      to: new Date(e.to)
+    };
+    a.from.setHours(0, 0, 0, 0), a.to.setHours(0, 0, 0, 0);
+    const n = E.value.map((l) => l.id);
+    if (Object.keys(k.value).forEach((l) => {
+      const M = k.value[l];
+      if (l !== "custom" && !t && n.indexOf(l) !== -1) {
+        const d = M.dates();
+        d.from.setHours(0, 0, 0, 0), d.to.setHours(0, 0, 0, 0), U(d.from, a.from) && U(d.to, a.to) && (f.value = l, t = !0);
+      }
+    }), t) {
+      const l = E.value.find(
+        (M) => M.id === f.value
+      );
+      y("dateRangePresetNameChanged", l.name);
+    } else
+      y("dateRangePresetNameChanged", null), f.value = "custom";
+    T.value = f.value;
+  }, A = (e, t, a) => {
+    if (!c.value.started)
+      f.value = "custom", c.value.started = !0, c.value.date = new Date(a, t, e.value), D(
+        { from: c.value.date, to: c.value.date },
+        !0
+      );
+    else {
+      const n = new Date(a, t, e.value), l = c.value.date;
+      c.value.started = !1, c.value.date = null, n < l ? A(e, t, a) : D({ from: l, to: n });
+    }
+  }, B = () => {
+    const e = N.value.offsetLeft;
+    return window.innerWidth - e > 930 ? "left" : "right";
+  }, W = (e = !0) => {
+    h.value = !h.value, h.value ? (j.value = B(), D(o.range), C(), y("opened")) : (D(o.range), C(), f.value = T.value, e && y("dismissed"));
+  }, G = () => {
+    h.value && W();
+  }, le = () => {
+    k.value = m.getPresetsFunctions(o.includeToday), k.value.custom = {
+      dates: () => o.range
+    };
+  }, oe = b(() => (g.value || []).reduce((e, t) => {
+    const n = s.value[t].parsedMonth.weeks[s.value[t].parsedMonth.weeks.length - 1].filter(
+      (l) => l.value !== 0
+    ).length;
+    return e && !n;
+  }, !0)), Y = () => {
+    o.range && (x.value = !0, z(o.initialType || o.types[0]), le(), $(o.range), D(o.range), C(), F());
+  };
+  ce(() => {
+    Y();
+  }), de(() => {
+    const e = (t) => {
+      t.key === "Escape" && h.value && G();
+    };
+    document.addEventListener("keyup", e), ve(() => {
+      document.removeEventListener("keyup", e);
+    });
+  }), Q(
+    () => o.range,
+    (e, t) => {
+      e && e !== t && (x.value ? ($(e), D(e), F()) : Y());
+    }
+  ), Q(h, (e) => {
+    e || (c.value.started = !1);
+  });
+  const J = b(() => {
+    const e = E.value.find(
+      (t) => t.id === f.value
+    );
+    return e ? e.name : "";
+  }), re = b(() => `datepicker${o.uniqueId}`), ue = b(() => {
+    const e = [o.maxDate, K.value].filter((t) => t);
+    return e.length ? me(e) : null;
+  });
+  return {
+    datePicker: N,
+    datePickerId: re,
+    getMaxAllowedDate: ue,
+    selectedPresetName: J,
+    selectedPreset: f,
+    displayError: w,
+    rangeType: P,
+    selectedRange: u,
+    placement: j,
+    currentDate: p,
+    error: O,
+    presets: E,
+    isOpen: h,
+    popup: q,
+    selectionStart: c,
+    initialized: x,
+    textDates: S,
+    currentMonths: s,
+    displayedMonthsKeys: g,
+    initMonths: C,
+    changeType: z,
+    presetChanged: ee,
+    initRange: D,
+    setCurrentDate: F,
+    apply: te,
+    getNavigation: ae,
+    navigationCallback: ne,
+    getSelectedRangeByType: R,
+    compareDates: U,
+    determinePreset: $,
+    selectionChanged: A,
+    checkPlacement: B,
+    toggle: W,
+    closeDatePicker: G,
+    isCompact: oe,
+    init: Y
+  };
+};
+export {
+  Te as dateRangeCommon
+};

package/components/dateRange/common/DateRangePicker.common.d.ts

@@ -0,0 +1,3 @@
+export declare const DateRangePickerCommon: (props: any) => {
+    componentId: import("vue").ComputedRef<string>;
+};

package/components/dateRange/{CalendarMonth.vue.d.ts → v3/CalendarMonth.vue.d.ts}

@@ -1,4 +1,4 @@
-import { Day } from './DateServices';
+import { Day } from '../common/DateServices.common';
 declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     year: number;
     days: Record<string, Day>;

package/components/dateRange/v3/CalendarMonth.vue.js

@@ -0,0 +1,7 @@
+import o from "./CalendarMonth.vue2.js";
+/* empty css                    */import e from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../CalendarMonth.vue_vue_type_style_index_0_scoped_acd3440c_lang.css"; //*');
+const c = /* @__PURE__ */ e(o, [["__scopeId", "data-v-acd3440c"]]);
+export {
+  c as default
+};