@bagelink/vue 1.2.13 → 1.2.18

package/dist/components/calendar/CalendarTypes.d.ts

@@ -0,0 +1,13 @@
+export interface CalendarEvent {
+    id: string;
+    title: string;
+    description?: string;
+    start_time: Date;
+    end_time: Date;
+    color?: string;
+    category?: string;
+    allDay?: boolean;
+}
+export type CalendarView = 'Week' | 'Month' | 'Day' | 'Agenda';
+export type WeekStart = 'Sunday' | 'Monday';
+//# sourceMappingURL=CalendarTypes.d.ts.map

package/dist/components/calendar/CalendarTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CalendarTypes.d.ts","sourceRoot":"","sources":["../../../src/components/calendar/CalendarTypes.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,IAAI,CAAA;IAChB,QAAQ,EAAE,IAAI,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CAChB;AACD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAA;AAE9D,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAA"}

package/dist/components/calendar/Index.vue.d.ts

@@ -1,519 +1,51 @@
-import { PropType } from 'vue';
-import { ConfigInterface } from './typings/config.interface';
-import { DayInterface } from './typings/interfaces/day.interface';
-import { EventInterface } from './typings/interfaces/event.interface';
-import { PeriodInterface } from './typings/interfaces/period.interface';
-import { ModeType } from './typings/types';
-import { default as Time } from './helpers/Time';
+import { CalendarEvent, CalendarView, WeekStart } from './CalendarTypes';
+interface CalendarProps {
+    events: CalendarEvent[];
+    startDate?: Date;
+    view?: CalendarView;
+    weekStart?: WeekStart;
+}
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
-        weekDayEvent?(_: {
-            eventData: {
-                id: import('./typings/interfaces/event.interface').EventID;
-                title?: string | undefined;
-                time: {
-                    start: string;
-                    end: string;
-                };
-                description?: string | undefined;
-                topic?: string | undefined;
-                location?: string | undefined;
-                with?: string | undefined;
-                colorScheme?: string | undefined;
-                color?: import('./typings/interfaces/event.interface').EventColor | undefined;
-                isEditable?: boolean | undefined;
-                disableDnD?: ModeType[] | undefined;
-                disableResize?: ModeType[] | undefined;
-                isCustom?: boolean | ModeType[] | undefined;
-                zIndex?: number | undefined;
-                nOfPreviousConcurrentEvents?: number | undefined;
-                totalConcurrentEvents?: number | undefined;
-                timeJS?: {
-                    start: Date;
-                    end: Date;
-                } | undefined;
-                originalEvent?: {
-                    with?: string | undefined;
-                    time: {
-                        start: string;
-                        end: string;
-                    };
-                    title?: string | undefined;
-                    id: import('./typings/interfaces/event.interface').EventID;
-                    color?: import('./typings/interfaces/event.interface').EventColor | undefined;
-                    description?: string | undefined;
-                    topic?: string | undefined;
-                    location?: string | undefined;
-                    colorScheme?: string | undefined;
-                    isEditable?: boolean | undefined;
-                    disableDnD?: ModeType[] | undefined;
-                    disableResize?: ModeType[] | undefined;
-                    isCustom?: boolean | ModeType[] | undefined;
-                    zIndex?: number | undefined;
-                    nOfPreviousConcurrentEvents?: number | undefined;
-                    totalConcurrentEvents?: number | undefined;
-                    timeJS?: {
-                        start: Date;
-                        end: Date;
-                    } | undefined;
-                    eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
-                } | undefined;
-                eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
-            };
-        }): any;
-        eventDialog?(_: {
-            eventDialogData: {
-                id: import('./typings/interfaces/event.interface').EventID;
-                title?: string | undefined;
-                time: {
-                    start: string;
-                    end: string;
-                };
-                description?: string | undefined;
-                topic?: string | undefined;
-                location?: string | undefined;
-                with?: string | undefined;
-                colorScheme?: string | undefined;
-                color?: import('./typings/interfaces/event.interface').EventColor | undefined;
-                isEditable?: boolean | undefined;
-                disableDnD?: ModeType[] | undefined;
-                disableResize?: ModeType[] | undefined;
-                isCustom?: boolean | ModeType[] | undefined;
-                zIndex?: number | undefined;
-                nOfPreviousConcurrentEvents?: number | undefined;
-                totalConcurrentEvents?: number | undefined;
-                timeJS?: {
-                    start: Date;
-                    end: Date;
-                } | undefined;
-                originalEvent?: {
-                    with?: string | undefined;
-                    time: {
-                        start: string;
-                        end: string;
-                    };
-                    title?: string | undefined;
-                    id: import('./typings/interfaces/event.interface').EventID;
-                    color?: import('./typings/interfaces/event.interface').EventColor | undefined;
-                    description?: string | undefined;
-                    topic?: string | undefined;
-                    location?: string | undefined;
-                    colorScheme?: string | undefined;
-                    isEditable?: boolean | undefined;
-                    disableDnD?: ModeType[] | undefined;
-                    disableResize?: ModeType[] | undefined;
-                    isCustom?: boolean | ModeType[] | undefined;
-                    zIndex?: number | undefined;
-                    nOfPreviousConcurrentEvents?: number | undefined;
-                    totalConcurrentEvents?: number | undefined;
-                    timeJS?: {
-                        start: Date;
-                        end: Date;
-                    } | undefined;
-                    eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
-                } | undefined;
-                eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
-            } | null;
-            closeEventDialog: () => void;
-        }): any;
-        eventDialog?(_: {
-            eventDialogData: {
-                id: import('./typings/interfaces/event.interface').EventID;
-                title?: string | undefined;
-                time: {
-                    start: string;
-                    end: string;
-                };
-                description?: string | undefined;
-                topic?: string | undefined;
-                location?: string | undefined;
-                with?: string | undefined;
-                colorScheme?: string | undefined;
-                color?: import('./typings/interfaces/event.interface').EventColor | undefined;
-                isEditable?: boolean | undefined;
-                disableDnD?: ModeType[] | undefined;
-                disableResize?: ModeType[] | undefined;
-                isCustom?: boolean | ModeType[] | undefined;
-                zIndex?: number | undefined;
-                nOfPreviousConcurrentEvents?: number | undefined;
-                totalConcurrentEvents?: number | undefined;
-                timeJS?: {
-                    start: Date;
-                    end: Date;
-                } | undefined;
-                originalEvent?: {
-                    with?: string | undefined;
-                    time: {
-                        start: string;
-                        end: string;
-                    };
-                    title?: string | undefined;
-                    id: import('./typings/interfaces/event.interface').EventID;
-                    color?: import('./typings/interfaces/event.interface').EventColor | undefined;
-                    description?: string | undefined;
-                    topic?: string | undefined;
-                    location?: string | undefined;
-                    colorScheme?: string | undefined;
-                    isEditable?: boolean | undefined;
-                    disableDnD?: ModeType[] | undefined;
-                    disableResize?: ModeType[] | undefined;
-                    isCustom?: boolean | ModeType[] | undefined;
-                    zIndex?: number | undefined;
-                    nOfPreviousConcurrentEvents?: number | undefined;
-                    totalConcurrentEvents?: number | undefined;
-                    timeJS?: {
-                        start: Date;
-                        end: Date;
-                    } | undefined;
-                    eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
-                } | undefined;
-                eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
-            } | null;
-            closeEventDialog: () => void;
-        }): any;
-        customCurrentTime?(_: {}): any;
-        monthEvent?(_: {
-            eventData: EventInterface;
-        }): any;
-        dayCell?(_: {
-            dayData: DayInterface;
+        eventContent?(_: {
+            event: any;
         }): any;
     };
-    refs: {
-        calendarRoot: HTMLDivElement;
-        appHeaderRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-            config: {
-                type: PropType<ConfigInterface>;
-                default: () => {};
-            };
-            mode: {
-                type: PropType<ModeType>;
-                default: string;
-            };
-            time: {
-                type: PropType<Time>;
-                default: () => {};
-            };
-            period: {
-                type: PropType<PeriodInterface>;
-                required: true;
-            };
-            isSmall: {
-                type: BooleanConstructor;
-                required: true;
-            };
-        }>> & Readonly<{
-            onChangeMode?: ((mode: ModeType) => any) | undefined;
-            onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-            changeMode: (mode: ModeType) => any;
-            updatedPeriod: (value: PeriodInterface) => any;
-        }, import('vue').PublicProps, {
-            time: Time;
-            mode: ModeType;
-            config: ConfigInterface;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-            periodSelect: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
-                modelValue: string | Date;
-            } & {
-                required?: boolean;
-                label?: string;
-                editMode?: boolean;
-                small?: boolean;
-                enableTime?: boolean;
-                modelValue?: string | Date;
-                min?: string | Date;
-                max?: string | Date;
-                mode?: ModeType;
-                defaultValue?: string | Date;
-                firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
-                locale?: string;
-                center?: boolean;
-            }> & Readonly<{
-                "onUpdate:modelValue"?: ((value: string | Date) => any) | undefined;
-            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                "update:modelValue": (value: string | Date) => any;
-            }, import('vue').PublicProps, {
-                small: boolean;
-                mode: ModeType;
-                editMode: boolean;
-                enableTime: boolean;
-                firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
-                locale: string;
-            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-                datePickerRef: HTMLDivElement;
-                calendarRef: HTMLDivElement;
-            }, HTMLDivElement, import('vue').ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<{
-                modelValue: string | Date;
-            } & {
-                required?: boolean;
-                label?: string;
-                editMode?: boolean;
-                small?: boolean;
-                enableTime?: boolean;
-                modelValue?: string | Date;
-                min?: string | Date;
-                max?: string | Date;
-                mode?: ModeType;
-                defaultValue?: string | Date;
-                firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
-                locale?: string;
-                center?: boolean;
-            }> & Readonly<{
-                "onUpdate:modelValue"?: ((value: string | Date) => any) | undefined;
-            }>, {}, {}, {}, {}, {
-                small: boolean;
-                mode: ModeType;
-                editMode: boolean;
-                enableTime: boolean;
-                firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
-                locale: string;
-            }> | null;
-        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('vue').ExtractPropTypes<{
-            config: {
-                type: PropType<ConfigInterface>;
-                default: () => {};
-            };
-            mode: {
-                type: PropType<ModeType>;
-                default: string;
-            };
-            time: {
-                type: PropType<Time>;
-                default: () => {};
-            };
-            period: {
-                type: PropType<PeriodInterface>;
-                required: true;
-            };
-            isSmall: {
-                type: BooleanConstructor;
-                required: true;
-            };
-        }>> & Readonly<{
-            onChangeMode?: ((mode: ModeType) => any) | undefined;
-            onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
-        }>, {}, {}, {}, {}, {
-            time: Time;
-            mode: ModeType;
-            config: ConfigInterface;
-        }> | null;
-    };
+    refs: {};
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    config: {
-        type: PropType<ConfigInterface>;
-        default: () => {};
-    };
-    events: {
-        type: PropType<EventInterface[]>;
-        default: () => never[];
-    };
-    selectedDate: {
-        type: DateConstructor;
-        default: Date;
-    };
-    isLoading: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    updatedPeriod: (...args: any[]) => void;
-    eventWasClicked: (...args: any[]) => void;
-    editEvent: (...args: any[]) => void;
-    deleteEvent: (...args: any[]) => void;
-    eventWasDragged: (...args: any[]) => void;
-    dateWasClicked: (...args: any[]) => void;
-    eventWasResized: (...args: any[]) => void;
-    intervalWasClicked: (...args: any[]) => void;
-    dayWasClicked: (...args: any[]) => void;
-    datetimeWasClicked: (...args: any[]) => void;
-    updatedMode: (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    config: {
-        type: PropType<ConfigInterface>;
-        default: () => {};
-    };
-    events: {
-        type: PropType<EventInterface[]>;
-        default: () => never[];
-    };
-    selectedDate: {
-        type: DateConstructor;
-        default: Date;
-    };
-    isLoading: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{
-    onUpdatedPeriod?: ((...args: any[]) => any) | undefined;
-    onEventWasClicked?: ((...args: any[]) => any) | undefined;
-    onEditEvent?: ((...args: any[]) => any) | undefined;
-    onDeleteEvent?: ((...args: any[]) => any) | undefined;
-    onEventWasDragged?: ((...args: any[]) => any) | undefined;
-    onDateWasClicked?: ((...args: any[]) => any) | undefined;
-    onEventWasResized?: ((...args: any[]) => any) | undefined;
-    onIntervalWasClicked?: ((...args: any[]) => any) | undefined;
-    onDayWasClicked?: ((...args: any[]) => any) | undefined;
-    onDatetimeWasClicked?: ((...args: any[]) => any) | undefined;
-    onUpdatedMode?: ((...args: any[]) => any) | undefined;
+declare const __VLS_component: import('vue').DefineComponent<CalendarProps, {
+    visibleDateRange: import('vue').ComputedRef<{
+        start: Date;
+        end: Date;
+    }>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    eventClick: (event: CalendarEvent) => any;
+    dateChange: (date: Date) => any;
+    eventCreate: (event: {
+        start_time: Date;
+        end_time: Date;
+    }) => any;
+    eventUpdate: (event: CalendarEvent) => any;
+    eventDelete: (eventId: string) => any;
+    viewChange: (view: CalendarView) => any;
+}, string, import('vue').PublicProps, Readonly<CalendarProps> & Readonly<{
+    onEventClick?: ((event: CalendarEvent) => any) | undefined;
+    onDateChange?: ((date: Date) => any) | undefined;
+    onEventCreate?: ((event: {
+        start_time: Date;
+        end_time: Date;
+    }) => any) | undefined;
+    onEventUpdate?: ((event: CalendarEvent) => any) | undefined;
+    onEventDelete?: ((eventId: string) => any) | undefined;
+    onViewChange?: ((view: CalendarView) => any) | undefined;
 }>, {
-    config: ConfigInterface;
-    selectedDate: Date;
-    events: EventInterface[];
-    isLoading: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    calendarRoot: HTMLDivElement;
-    appHeaderRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-        config: {
-            type: PropType<ConfigInterface>;
-            default: () => {};
-        };
-        mode: {
-            type: PropType<ModeType>;
-            default: string;
-        };
-        time: {
-            type: PropType<Time>;
-            default: () => {};
-        };
-        period: {
-            type: PropType<PeriodInterface>;
-            required: true;
-        };
-        isSmall: {
-            type: BooleanConstructor;
-            required: true;
-        };
-    }>> & Readonly<{
-        onChangeMode?: ((mode: ModeType) => any) | undefined;
-        onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
-    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-        changeMode: (mode: ModeType) => any;
-        updatedPeriod: (value: PeriodInterface) => any;
-    }, import('vue').PublicProps, {
-        time: Time;
-        mode: ModeType;
-        config: ConfigInterface;
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-        periodSelect: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
-            modelValue: string | Date;
-        } & {
-            required?: boolean;
-            label?: string;
-            editMode?: boolean;
-            small?: boolean;
-            enableTime?: boolean;
-            modelValue?: string | Date;
-            min?: string | Date;
-            max?: string | Date;
-            mode?: ModeType;
-            defaultValue?: string | Date;
-            firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
-            locale?: string;
-            center?: boolean;
-        }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: string | Date) => any) | undefined;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            "update:modelValue": (value: string | Date) => any;
-        }, import('vue').PublicProps, {
-            small: boolean;
-            mode: ModeType;
-            editMode: boolean;
-            enableTime: boolean;
-            firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
-            locale: string;
-        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-            datePickerRef: HTMLDivElement;
-            calendarRef: HTMLDivElement;
-        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<{
-            modelValue: string | Date;
-        } & {
-            required?: boolean;
-            label?: string;
-            editMode?: boolean;
-            small?: boolean;
-            enableTime?: boolean;
-            modelValue?: string | Date;
-            min?: string | Date;
-            max?: string | Date;
-            mode?: ModeType;
-            defaultValue?: string | Date;
-            firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
-            locale?: string;
-            center?: boolean;
-        }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: string | Date) => any) | undefined;
-        }>, {}, {}, {}, {}, {
-            small: boolean;
-            mode: ModeType;
-            editMode: boolean;
-            enableTime: boolean;
-            firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
-            locale: string;
-        }> | null;
-    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import('vue').ExtractPropTypes<{
-        config: {
-            type: PropType<ConfigInterface>;
-            default: () => {};
-        };
-        mode: {
-            type: PropType<ModeType>;
-            default: string;
-        };
-        time: {
-            type: PropType<Time>;
-            default: () => {};
-        };
-        period: {
-            type: PropType<PeriodInterface>;
-            required: true;
-        };
-        isSmall: {
-            type: BooleanConstructor;
-            required: true;
-        };
-    }>> & Readonly<{
-        onChangeMode?: ((mode: ModeType) => any) | undefined;
-        onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
-    }>, {}, {}, {}, {}, {
-        time: Time;
-        mode: ModeType;
-        config: ConfigInterface;
-    }> | null;
-}, HTMLDivElement>;
+    view: CalendarView;
+    startDate: Date;
+    weekStart: WeekStart;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/components/calendar/Index.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Index.vue.d.ts","sourceRoot":"","sources":["../../../src/components/calendar/Index.vue"],"names":[],"mappings":"AAmaA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA;AAC5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAO/C,OAAO,IAAI,MAAM,gBAAgB,CAAA;AA4MjC,iBAAS,cAAc;WAwTT,OAAO,IAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAjBf,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAEH,GAAG;mCADG,GAAG;;;YAEV,GAAG;;;YACN,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBhC;AA6CD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;cAQH,QAAQ,CAAC,eAAe,CAAC;;;;cAI1B,QAAQ,CAAC,cAAc,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;cAJzB,QAAQ,CAAC,eAAe,CAAC;;;;cAI1B,QAAQ,CAAC,cAAc,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAczC,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAEpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"Index.vue.d.ts","sourceRoot":"","sources":["../../../src/components/calendar/Index.vue"],"names":[],"mappings":"AA2JA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAQ7E,UAAU,aAAa;IACtB,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,SAAS,CAAC,EAAE,IAAI,CAAA;IAChB,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,SAAS,CAAC,EAAE,SAAS,CAAA;CACrB;AAyFD,iBAAS,cAAc;WAkMT,OAAO,IAA6B;;;;YAVf,GAAG;;;;EAerC;AAwBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;oBA9SoB,IAAI;kBAAY,IAAI;;;;;;;;;oBAApB,IAAI;kBAAY,IAAI;;;;;;UAbrD,YAAY;eADP,IAAI;eAEJ,SAAS;wFAoUpB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/calendar/utils.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { CalendarEvent } from './CalendarTypes';
+export interface PopoverState {
+    activeEvent: Ref<CalendarEvent | null>;
+    showPopover: Ref<boolean>;
+    popoverPosition: Ref<{
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    }>;
+    popoverRef: Ref<HTMLElement | null>;
+}
+/**
+ * Positions the popover to be centered on the target element and ensures it stays within viewport
+ */
+export declare function calculatePopoverPosition(target: HTMLElement, popoverWidth?: number, popoverHeight?: number): {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+/**
+ * Opens a popover for a calendar event
+ */
+export declare function openPopover(event: CalendarEvent, e: MouseEvent, state: PopoverState, hasEventContentSlot: boolean, emitEventClick: (event: CalendarEvent) => void): void;
+/**
+ * Closes the popover
+ */
+export declare function closePopover(state: PopoverState): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/components/calendar/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/components/calendar/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,MAAM,WAAW,YAAY;IAC5B,WAAW,EAAE,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IACtC,WAAW,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACzB,eAAe,EAAE,GAAG,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClF,UAAU,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,WAAW,EACnB,YAAY,SAAM,EAClB,aAAa,SAAM,GACjB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAsB9D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,aAAa,EACpB,CAAC,EAAE,UAAU,EACb,KAAK,EAAE,YAAY,EACnB,mBAAmB,EAAE,OAAO,EAC5B,cAAc,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,QAY9C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,QAG/C"}

package/dist/components/calendar/views/AgendaView.vue.d.ts

@@ -0,0 +1,16 @@
+import { CalendarEvent } from '../CalendarTypes';
+type __VLS_Props = {
+    events: CalendarEvent[];
+    startDate: Date;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    eventClick: (event: CalendarEvent) => any;
+    dateChange: (date: Date) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEventClick?: ((event: CalendarEvent) => any) | undefined;
+    onDateChange?: ((date: Date) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=AgendaView.vue.d.ts.map

package/dist/components/calendar/views/AgendaView.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgendaView.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/calendar/views/AgendaView.vue"],"names":[],"mappings":"AAyQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAUrD,KAAK,WAAW,GAAG;IAClB,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,SAAS,EAAE,IAAI,CAAA;CACf,CAAC;;;;;;;;;;AAoNF,wBASG"}