vlite3 1.0.10 → 1.1.2

package/components/AvatarGroup/AvatarGroup.vue.js

@@ -0,0 +1,91 @@
+import { defineComponent as k, computed as u, openBlock as l, createElementBlock as s, normalizeClass as a, Fragment as z, renderList as b, createVNode as f, withCtx as x, createElementVNode as y, toDisplayString as r, createCommentVNode as o, normalizeStyle as C } from "vue";
+import p from "../Avatar.vue.js";
+import S from "../Tooltip.vue.js";
+const w = { class: "flex flex-col gap-0.5 text-left" }, N = {
+  key: 0,
+  class: "font-semibold text-sm text-tooltip-foreground"
+}, V = {
+  key: 1,
+  class: "text-xs text-tooltip-foreground/70"
+}, g = "ring-2 ring-background", D = /* @__PURE__ */ k({
+  __name: "AvatarGroup",
+  props: {
+    items: {},
+    max: { default: 4 },
+    size: { default: "md" },
+    rounded: { default: "full" },
+    overlap: { default: "md" },
+    class: { default: "" }
+  },
+  setup(e) {
+    const n = e, v = u(() => n.items.slice(0, n.max)), d = u(() => Math.max(0, n.items.length - n.max)), m = {
+      sm: "-ml-1",
+      md: "-ml-2",
+      lg: "-ml-3"
+    }, i = {
+      xs: "1.5rem",
+      sm: "1.875rem",
+      md: "2.5rem",
+      lg: "3.5rem",
+      xl: "4.5rem",
+      "2xl": "5.5rem"
+    }, h = {
+      xs: "10px",
+      sm: "0.75rem",
+      md: "0.875rem",
+      lg: "1rem",
+      xl: "1.125rem",
+      "2xl": "1.25rem"
+    };
+    return ($, B) => (l(), s("div", {
+      class: a(["flex items-center", n.class])
+    }, [
+      (l(!0), s(z, null, b(v.value, (t, c) => (l(), s("div", {
+        key: c,
+        class: a([c !== 0 ? m[e.overlap] : "", "relative shrink-0"])
+      }, [
+        f(S, {
+          disabled: !t.heading && !t.text,
+          placement: "top"
+        }, {
+          content: x(() => [
+            y("div", w, [
+              t.heading ? (l(), s("span", N, r(t.heading), 1)) : o("", !0),
+              t.text ? (l(), s("span", V, r(t.text), 1)) : o("", !0)
+            ])
+          ]),
+          default: x(() => [
+            f(p, {
+              src: t.src,
+              alt: t.alt,
+              fallback: t.fallback,
+              size: e.size,
+              rounded: e.rounded,
+              class: a(g)
+            }, null, 8, ["src", "alt", "fallback", "size", "rounded"])
+          ]),
+          _: 2
+        }, 1032, ["disabled"])
+      ], 2))), 128)),
+      d.value > 0 ? (l(), s("div", {
+        key: 0,
+        class: a([
+          m[e.overlap],
+          "relative shrink-0 flex items-center justify-center",
+          "bg-muted text-muted-foreground font-medium",
+          g,
+          e.rounded === "full" ? "rounded-full" : e.rounded === "none" ? "rounded-none" : `rounded-${e.rounded}`
+        ]),
+        style: C({
+          // Match the same size as Avatar sizeClasses
+          width: i[e.size],
+          height: i[e.size],
+          fontSize: h[e.size]
+        })
+      }, " +" + r(d.value), 7)) : o("", !0)
+    ], 2));
+  }
+});
+export {
+  D as default
+};

package/components/AvatarGroup/AvatarGroup.vue2.js

@@ -0,0 +1,4 @@
+import f from "./AvatarGroup.vue.js";
+export {
+  f as default
+};

package/components/AvatarGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AvatarGroup } from './AvatarGroup.vue';
+export type { AvatarGroupItem } from './AvatarGroup.vue';

package/components/AvatarUploader/AvatarUploader.vue.d.ts

@@ -24,8 +24,8 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     alt: string;
     size: AvatarSize;
     rounded: AvatarRounded;
-    disabled: boolean;
     loading: boolean;
+    disabled: boolean;
     modelValue: any;
     editable: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;

package/components/Barcode/Barcode.vue.js

@@ -1,4 +1,4 @@
-import { defineComponent as d, ref as i, onMounted as f, watch as m, openBlock as r, createElementBlock as l, toDisplayString as p, createCommentVNode as v, withDirectives as h, vShow as g } from "vue";
+import { defineComponent as d, ref as s, onMounted as f, watch as m, openBlock as r, createElementBlock as l, toDisplayString as p, createCommentVNode as v, withDirectives as h, vShow as g } from "vue";
 import w from "jsbarcode";
 import { barcodesConstants as b } from "./types.js";
 const y = { class: "inline-flex justify-center items-center max-w-full flex-col gap-2" }, x = {
@@ -17,20 +17,21 @@ const y = { class: "inline-flex justify-center items-center max-w-full flex-col
     margin: { default: 10 }
   },
   setup(u) {
-    const e = u, o = i(null), a = i(""), n = () => {
+    const e = u, o = s(null), a = s(""), n = () => {
       if (a.value = "", o.value && e.value) {
         o.value.innerHTML = "";
         try {
           const t = b.find(
             (c) => c.value.toLowerCase() === e.format.toLowerCase()
-          ), s = t ? t.value : e.format;
+          ), i = t ? t.value : e.format;
           w(o.value, e.value, {
-            format: s,
+            format: i,
             displayValue: e.displayValue,
             width: e.width,
             height: e.height,
             lineColor: e.lineColor,
             background: e.background,
+            fontSize: 12,
             margin: e.margin
           });
         } catch (t) {
@@ -40,7 +41,7 @@ const y = { class: "inline-flex justify-center items-center max-w-full flex-col
     };
     return f(() => {
       n();
-    }), m(() => e, n, { deep: !0 }), (t, s) => (r(), l("div", y, [
+    }), m(() => e, n, { deep: !0 }), (t, i) => (r(), l("div", y, [
       a.value ? (r(), l("div", x, p(a.value), 1)) : v("", !0),
       h((r(), l("svg", {
         ref_key: "barcodeRef",

package/components/Button.vue.d.ts

@@ -15,8 +15,8 @@ declare const __VLS_component: import('vue').DefineComponent<ButtonProps, {}, {}
     variant: ButtonVariant;
     size: ButtonSize;
     rounded: ButtonRounded;
-    disabled: boolean;
     loading: boolean;
+    disabled: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLButtonElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/components/Calendar/Calendar.vue.d.ts

@@ -0,0 +1,229 @@
+type __VLS_Props = {
+    events: any[];
+    loading?: boolean;
+    canAdd?: boolean;
+    canEdit?: boolean;
+    canDelete?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    eventClick: (...args: any[]) => void;
+    eventCreate: (...args: any[]) => void;
+    eventUpdate: (...args: any[]) => void;
+    eventEdit: (...args: any[]) => void;
+    eventDelete: (...args: any[]) => void;
+    dateChange: (...args: any[]) => void;
+    dayClick: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEventClick?: (...args: any[]) => any;
+    onEventCreate?: (...args: any[]) => any;
+    onEventUpdate?: (...args: any[]) => any;
+    onEventEdit?: (...args: any[]) => any;
+    onEventDelete?: (...args: any[]) => any;
+    onDateChange?: (...args: any[]) => any;
+    onDayClick?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    calendarRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            allowEventCreation: boolean;
+            maxEventsPerDay: number;
+            showWeekNumbers: boolean;
+            events: import('v-event-calendar').CalendarEvent[];
+            initialView: import('v-event-calendar').CalendarView;
+            allowEventEditing: boolean;
+        }> & Omit<{
+            readonly events: import('v-event-calendar').CalendarEvent[];
+            readonly initialView: import('v-event-calendar').CalendarView;
+            readonly allowEventCreation: boolean;
+            readonly allowEventEditing: boolean;
+            readonly maxEventsPerDay: number;
+            readonly showWeekNumbers: boolean;
+            readonly config?: Partial<import('v-event-calendar').CalendarViewConfig>;
+            readonly onEventUpdate?: (eventId: string, start: string, end?: string, duration?: number) => any;
+            readonly onDayClick?: (date: Date) => any;
+            readonly onEventClick?: (event: import('v-event-calendar').CalendarEvent) => any;
+            readonly onDateChange?: (date: Date) => any;
+            readonly onViewChange?: (view: import('v-event-calendar').CalendarView) => any;
+            readonly onEventCreate?: (date: Date, start: string, end?: string, duration?: number) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "events" | "initialView" | "allowEventCreation" | "allowEventEditing" | "maxEventsPerDay" | "showWeekNumbers">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "eventClick", event: import('v-event-calendar').CalendarEvent) => void) & ((event: "eventCreate", date: Date, start: string, end?: string, duration?: number) => void) & ((event: "eventUpdate", eventId: string, start: string, end?: string, duration?: number) => void) & ((event: "dateChange", date: Date) => void) & ((event: "dayClick", date: Date) => void) & ((event: "viewChange", view: import('v-event-calendar').CalendarView) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            config: {
+                type: import('vue').PropType<Partial<import('v-event-calendar').CalendarViewConfig>>;
+            };
+            events: {
+                type: import('vue').PropType<import('v-event-calendar').CalendarEvent[]>;
+                default: () => any[];
+            };
+            initialView: {
+                type: import('vue').PropType<import('v-event-calendar').CalendarView>;
+                default: string;
+            };
+            allowEventCreation: {
+                type: import('vue').PropType<boolean>;
+                default: boolean;
+            };
+            allowEventEditing: {
+                type: import('vue').PropType<boolean>;
+                default: boolean;
+            };
+            maxEventsPerDay: {
+                type: import('vue').PropType<number>;
+                default: number;
+            };
+            showWeekNumbers: {
+                type: import('vue').PropType<boolean>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onEventUpdate?: (eventId: string, start: string, end?: string, duration?: number) => any;
+            onDayClick?: (date: Date) => any;
+            onEventClick?: (event: import('v-event-calendar').CalendarEvent) => any;
+            onDateChange?: (date: Date) => any;
+            onViewChange?: (view: import('v-event-calendar').CalendarView) => any;
+            onEventCreate?: (date: Date, start: string, end?: string, duration?: number) => any;
+        }>, {
+            forceUpdate: () => void;
+            view: import('vue').Ref<import('v-event-calendar').CalendarView, import('v-event-calendar').CalendarView>;
+            canGoNext: import('vue').ComputedRef<boolean>;
+            goToDate: (date: Date) => void;
+            goToNext: () => void;
+            setView: (newView: import('v-event-calendar').CalendarView) => void;
+            title: string;
+            goToToday: () => void;
+            canGoPrevious: import('vue').ComputedRef<boolean>;
+            selectDate: (date: Date) => void;
+            goToPrevious: () => void;
+            currentDate: import('vue').Ref<Date, Date>;
+            selectedDate: import('vue').Ref<Date, Date>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            dayClick: (date: Date) => void;
+            dateChange: (date: Date) => void;
+            eventClick: (event: import('v-event-calendar').CalendarEvent) => void;
+            viewChange: (view: import('v-event-calendar').CalendarView) => void;
+            eventCreate: (date: Date, start: string, end?: string, duration?: number) => void;
+            eventUpdate: (eventId: string, start: string, end?: string, duration?: number) => void;
+        }, string, {
+            allowEventCreation: boolean;
+            maxEventsPerDay: number;
+            showWeekNumbers: boolean;
+            events: import('v-event-calendar').CalendarEvent[];
+            initialView: import('v-event-calendar').CalendarView;
+            allowEventEditing: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            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 | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, 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: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        allowEventCreation: boolean;
+        maxEventsPerDay: number;
+        showWeekNumbers: boolean;
+        events: import('v-event-calendar').CalendarEvent[];
+        initialView: import('v-event-calendar').CalendarView;
+        allowEventEditing: boolean;
+    }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: import('vue').PropType<Partial<import('v-event-calendar').CalendarViewConfig>>;
+        };
+        events: {
+            type: import('vue').PropType<import('v-event-calendar').CalendarEvent[]>;
+            default: () => any[];
+        };
+        initialView: {
+            type: import('vue').PropType<import('v-event-calendar').CalendarView>;
+            default: string;
+        };
+        allowEventCreation: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        allowEventEditing: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        maxEventsPerDay: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        showWeekNumbers: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onEventUpdate?: (eventId: string, start: string, end?: string, duration?: number) => any;
+        onDayClick?: (date: Date) => any;
+        onEventClick?: (event: import('v-event-calendar').CalendarEvent) => any;
+        onDateChange?: (date: Date) => any;
+        onViewChange?: (view: import('v-event-calendar').CalendarView) => any;
+        onEventCreate?: (date: Date, start: string, end?: string, duration?: number) => any;
+    }>, "title" | "view" | "canGoPrevious" | "canGoNext" | "events" | "initialView" | "allowEventCreation" | "allowEventEditing" | "maxEventsPerDay" | "showWeekNumbers" | "forceUpdate" | "goToDate" | "goToNext" | "setView" | "goToToday" | "selectDate" | "goToPrevious" | "currentDate" | "selectedDate"> & import('vue').ShallowUnwrapRef<{
+        forceUpdate: () => void;
+        view: import('vue').Ref<import('v-event-calendar').CalendarView, import('v-event-calendar').CalendarView>;
+        canGoNext: import('vue').ComputedRef<boolean>;
+        goToDate: (date: Date) => void;
+        goToNext: () => void;
+        setView: (newView: import('v-event-calendar').CalendarView) => void;
+        title: string;
+        goToToday: () => void;
+        canGoPrevious: import('vue').ComputedRef<boolean>;
+        selectDate: (date: Date) => void;
+        goToPrevious: () => void;
+        currentDate: import('vue').Ref<Date, Date>;
+        selectedDate: import('vue').Ref<Date, Date>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            header?(_: {
+                currentTitle: string;
+                view: import('v-event-calendar').CalendarView;
+                canGoNext: boolean;
+                goToDate: (date: Date) => void;
+                goToNext: () => void;
+                setView: (newView: import('v-event-calendar').CalendarView) => void;
+                goToToday: () => void;
+                canGoPrevious: boolean;
+                selectDate: (date: Date) => void;
+                goToPrevious: () => void;
+                currentDate: Date;
+                selectedDate: Date;
+            }): any;
+            event?(_: {
+                event: import('v-event-calendar').CalendarEvent;
+                displayTime: string;
+                view: "month" | "date" | "week";
+                isMultiDay: boolean;
+                isContained: boolean;
+            }): any;
+        };
+    };
+}, HTMLDivElement>;
+export default _default;

package/components/Calendar/Calendar.vue.js

@@ -0,0 +1,7 @@
+import o from "./Calendar.vue2.js";
+/* empty css              */
+import r from "../../_virtual/_plugin-vue_export-helper.js";
+const f = /* @__PURE__ */ r(o, [["__scopeId", "data-v-63e46f6b"]]);
+export {
+  f as default
+};

package/components/Calendar/Calendar.vue2.js

@@ -0,0 +1,186 @@
+import { defineComponent as _, ref as k, onMounted as M, onUnmounted as W, computed as p, openBlock as b, createElementBlock as E, createVNode as n, unref as j, withCtx as i, createElementVNode as w, createTextVNode as f, toDisplayString as r } from "vue";
+import A from "v-event-calendar";
+import l from "../Button.vue.js";
+import h from "../ButtonGroup.vue.js";
+import { $t as B } from "../../utils/i18n.js";
+import "v-event-calendar/style.css";
+import L from "./CalendarEventItem.vue.js";
+const P = { class: "h-[calc(100vh-1px)] v-calendar lg:mt-2 bg-body border border-border rounded-xl shadow-sm overflow-hidden flex flex-col" }, R = {
+  key: 0,
+  class: "flex items-center justify-between p-4 border-b border-border bg-body"
+}, G = { class: "flex items-center gap-2" }, I = { class: "text-lg font-bold text-foreground truncate mx-2" }, q = { class: "flex items-center gap-2" }, F = {
+  key: 1,
+  class: "flex max-sm:flex-col sm:justify-between gap-2 sm:px-4 py-4 border-b border-border bg-body"
+}, H = { class: "text-base font-bold text-foreground text-center" }, ee = /* @__PURE__ */ _({
+  __name: "Calendar",
+  props: {
+    events: {},
+    loading: { type: Boolean },
+    canAdd: { type: Boolean },
+    canEdit: { type: Boolean },
+    canDelete: { type: Boolean }
+  },
+  emits: [
+    "eventClick",
+    "eventCreate",
+    "eventUpdate",
+    "eventEdit",
+    "eventDelete",
+    "dateChange",
+    "dayClick"
+  ],
+  setup(c, { emit: $ }) {
+    const d = $, s = k(), v = k("month"), x = k(!1), C = () => {
+      const o = window.innerWidth < 1200;
+      o !== x.value && (x.value = o, o && (v.value = "date", s.value?.setView("date")));
+    };
+    M(() => {
+      C(), window.addEventListener("resize", C);
+    }), W(() => {
+      window.removeEventListener("resize", C);
+    });
+    const g = (o) => {
+      x.value || (v.value = o, s.value?.setView(o));
+    }, z = () => s.value?.goToToday(), T = () => s.value?.goToPrevious(), D = () => s.value?.goToNext(), y = (o, e, t) => {
+      const a = t ? B(o, t) : B(o);
+      return a !== o ? a : e;
+    }, N = p(() => y("vlite.calendar.month", "Month")), S = p(() => y("vlite.calendar.week", "Week")), U = p(() => y("vlite.calendar.day", "Day")), V = p(() => y("vlite.calendar.today", "Today"));
+    return (o, e) => (b(), E("div", P, [
+      n(j(A), {
+        ref_key: "calendarRef",
+        ref: s,
+        events: c.events,
+        "initial-view": v.value,
+        "allow-event-creation": c.canAdd,
+        "allow-event-editing": c.canEdit,
+        onEventClick: e[6] || (e[6] = (t) => d("eventClick", t)),
+        onEventCreate: e[7] || (e[7] = (t, a, u) => d("eventCreate", { date: t, start: a, end: u })),
+        onEventUpdate: e[8] || (e[8] = (t, a, u) => d("eventUpdate", { eventId: t, start: a, end: u })),
+        onDateChange: e[9] || (e[9] = (t) => d("dateChange", t)),
+        onDayClick: e[10] || (e[10] = (t) => d("dayClick", t)),
+        class: "flex-1 min-h-0"
+      }, {
+        header: i(({ currentTitle: t }) => [
+          x.value ? (b(), E("div", F, [
+            w("h2", H, r(t), 1),
+            n(h, { class: "max-sm:w-full" }, {
+              default: i(() => [
+                n(l, {
+                  variant: "outline",
+                  size: "sm",
+                  icon: "lucide:chevron-left",
+                  onClick: T
+                }),
+                n(l, {
+                  variant: "outline",
+                  size: "sm",
+                  class: "flex-1",
+                  onClick: z
+                }, {
+                  default: i(() => [
+                    f(r(V.value), 1)
+                  ]),
+                  _: 1
+                }),
+                n(l, {
+                  variant: "outline",
+                  size: "sm",
+                  icon: "lucide:chevron-right",
+                  onClick: D
+                })
+              ]),
+              _: 1
+            })
+          ])) : (b(), E("div", R, [
+            w("div", G, [
+              n(h, null, {
+                default: i(() => [
+                  n(l, {
+                    variant: v.value === "month" ? "primary" : "outline",
+                    size: "sm",
+                    icon: "lucide:calendar-days",
+                    onClick: e[0] || (e[0] = (a) => g("month"))
+                  }, {
+                    default: i(() => [
+                      f(r(N.value), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["variant"]),
+                  n(l, {
+                    variant: v.value === "week" ? "primary" : "outline",
+                    size: "sm",
+                    icon: "lucide:calendar-range",
+                    onClick: e[1] || (e[1] = (a) => g("week"))
+                  }, {
+                    default: i(() => [
+                      f(r(S.value), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["variant"]),
+                  n(l, {
+                    variant: v.value === "date" ? "primary" : "outline",
+                    size: "sm",
+                    icon: "lucide:calendar",
+                    onClick: e[2] || (e[2] = (a) => g("date"))
+                  }, {
+                    default: i(() => [
+                      f(r(U.value), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["variant"])
+                ]),
+                _: 1
+              })
+            ]),
+            w("h2", I, r(t), 1),
+            w("div", q, [
+              n(h, null, {
+                default: i(() => [
+                  n(l, {
+                    variant: "outline",
+                    size: "sm",
+                    icon: "lucide:chevron-left",
+                    onClick: T
+                  }),
+                  n(l, {
+                    variant: "outline",
+                    size: "sm",
+                    onClick: z
+                  }, {
+                    default: i(() => [
+                      f(r(V.value), 1)
+                    ]),
+                    _: 1
+                  }),
+                  n(l, {
+                    variant: "outline",
+                    size: "sm",
+                    icon: "lucide:chevron-right",
+                    onClick: D
+                  })
+                ]),
+                _: 1
+              })
+            ])
+          ]))
+        ]),
+        event: i(({ event: t, view: a, displayTime: u }) => [
+          n(L, {
+            event: t,
+            view: a,
+            displayTime: u,
+            "can-edit": c.canEdit,
+            "can-delete": c.canDelete,
+            onView: e[3] || (e[3] = (m) => d("eventClick", m)),
+            onEdit: e[4] || (e[4] = (m) => d("eventEdit", m)),
+            onDelete: e[5] || (e[5] = (m) => d("eventDelete", m))
+          }, null, 8, ["event", "view", "displayTime", "can-edit", "can-delete"])
+        ]),
+        _: 1
+      }, 8, ["events", "initial-view", "allow-event-creation", "allow-event-editing"])
+    ]));
+  }
+});
+export {
+  ee as default
+};

package/components/Calendar/CalendarEventItem.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    event: any;
+    view: string;
+    displayTime?: string;
+    canEdit?: boolean;
+    canDelete?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    view: (...args: any[]) => void;
+    delete: (...args: any[]) => void;
+    edit: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onView?: (...args: any[]) => any;
+    onDelete?: (...args: any[]) => any;
+    onEdit?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;