@farris/ui-vue 1.0.0-beta.6 → 1.0.0

package/types/button-edit/src/composition/use-clear.d.ts

@@ -15,5 +15,5 @@
  */
 import { ComputedRef, Ref, SetupContext } from 'vue';
 import { ButtonEditProps } from '../button-edit.props';
-import { UseClear } from './types';
-export declare function useClear(props: ButtonEditProps, context: SetupContext, modelValue: Ref<string>, hasFocusedTextBox: ComputedRef<boolean>, displayText: Ref<string>): UseClear;
+import { UseClear, UseTextBox } from './types';
+export declare function useClear(props: ButtonEditProps, context: SetupContext, modelValue: Ref<string>, hasFocusedTextBox: ComputedRef<boolean>, displayText: Ref<string>, useTextBoxCompostion: UseTextBox): UseClear;

package/types/button-edit/src/composition/use-popup.d.ts

@@ -0,0 +1,4 @@
+import { Ref, SetupContext } from "vue";
+import { ButtonEditProps } from "../button-edit.props";
+import { UsePopup } from "./types";
+export declare function usePopup(props: ButtonEditProps, context: SetupContext, buttonEditRef: Ref<any>): UsePopup;

package/types/button-edit/src/composition/use-text-box.d.ts

@@ -15,5 +15,5 @@
  */
 import { Ref, SetupContext } from 'vue';
 import { ButtonEditProps } from '../button-edit.props';
-import { UseTextBox } from './types';
-export declare function useTextBox(props: ButtonEditProps, context: SetupContext, modelValue: Ref<string>, displayText: Ref<string>): UseTextBox;
+import { UsePopup, UseTextBox } from './types';
+export declare function useTextBox(props: ButtonEditProps, context: SetupContext, modelValue: Ref<string>, displayText: Ref<string>, usePopupComposition: UsePopup): UseTextBox;

package/types/button-edit/src/schema/schema-mapper.d.ts

@@ -0,0 +1,2 @@
+import { MapperFunction } from '../../../dynamic-resolver';
+export declare const schemaMapper: Map<string, string | MapperFunction>;

package/types/{data-grid/src/composition/use-fit-column.d.ts → calculator/index.d.ts}

@@ -13,8 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Ref } from 'vue';
-import { DataGridProps } from '../data-grid.props';
-import { UseFitColumn } from './types';
-import { ColumnRenderContext } from './use-column';
-export declare function useFitColumn(props: DataGridProps, context: Ref<ColumnRenderContext>): UseFitColumn;
+import type { App } from 'vue';
+import calculator from './src/calculator.component';
+export * from './src/calculator.props';
+export { calculator };
+declare const _default: {
+    install(app: App): void;
+};
+export default _default;

package/types/{combo-list/src/components/options.component.d.ts → calculator/src/calculator.component.d.ts}

@@ -1,11 +1,7 @@
 declare const _default: import("vue").DefineComponent<{
-    options: {
-        type: import("vue").PropType<import("../types").Options>;
-    };
+    id: StringConstructor;
 }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    options: {
-        type: import("vue").PropType<import("../types").Options>;
-    };
+    id: StringConstructor;
 }>> & {
     [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
 }, {}>;

package/types/calculator/src/calculator.props.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2020 - present, Inspur Genersoft Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ExtractPropTypes } from 'vue';
+export declare const calculatorProps: {
+    /**
+     * 组件标识
+     */
+    id: StringConstructor;
+};
+export type CalculatorProps = ExtractPropTypes<typeof calculatorProps>;

package/types/calculator/src/composition/use-calculator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2020 - present, Inspur Genersoft Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function useCalculator(): {
+    strip: (num: number, precision?: number) => number;
+    plus: (num1: number, num2: number, ...others: number[]) => number;
+    minus: (num1: number, num2: number, ...others: number[]) => number;
+    times: (num1: number, num2: number, ...others: number[]) => number;
+    divide: (num1: number, num2: number, ...others: number[]) => number;
+    round: (num: number, ratio: number) => number;
+    digitLength: (num: number) => number;
+    float2Fixed: (num: number) => number;
+    enableBoundaryChecking: (flag?: boolean) => void;
+};

package/types/calendar/index.d.ts

@@ -0,0 +1,21 @@
+import type { App } from 'vue';
+import Calendar from './src/calendar.component';
+import CalendarHeader from './src/components/header/header.component';
+import CalendarDayView from './src/components/day/day-view.component';
+import CalendarMonthView from './src/components/month/month-view.component';
+import CalendarWeekView from './src/components/week/week-view.component';
+export * from './src/calendar.props';
+export * from './src/components/day/day-view.props';
+export * from './src/components/header/header.props';
+export * from './src/components/month/month-view.props';
+export * from './src/components/week/week-view.props';
+export * from './src/types/calendar';
+export * from './src/types/common';
+export * from './src/types/month';
+export * from './src/types/month-view';
+export * from './src/types/schedule';
+export { Calendar, CalendarDayView, CalendarHeader, CalendarMonthView, CalendarWeekView };
+declare const _default: {
+    install(app: App): void;
+};
+export default _default;

package/types/calendar/src/calendar.props.d.ts

@@ -0,0 +1,26 @@
+import { ExtractPropTypes } from 'vue';
+import { ScheduleEvent } from './types/schedule';
+export declare const calendarProps: {
+    events: {
+        Type: {
+            (arrayLength: number): ScheduleEvent[];
+            (...items: ScheduleEvent[]): ScheduleEvent[];
+            new (arrayLength: number): ScheduleEvent[];
+            new (...items: ScheduleEvent[]): ScheduleEvent[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    firstDayOfTheWeek: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type CalendarPropsType = ExtractPropTypes<typeof calendarProps>;

package/types/calendar/src/components/day/day-view.props.d.ts

@@ -0,0 +1,34 @@
+import { ExtractPropTypes } from 'vue';
+import { EventItem } from '../../types/common';
+export declare const dayViewProps: {
+    day: {
+        Type: ObjectConstructor;
+        default: {};
+    };
+    dayInWeek: {
+        Type: StringConstructor;
+        default: string;
+    };
+    enableMarkCurrent: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    events: {
+        Type: {
+            (arrayLength: number): EventItem[];
+            (...items: EventItem[]): EventItem[];
+            new (arrayLength: number): EventItem[];
+            new (...items: EventItem[]): EventItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+};
+export type DayViewPropsType = ExtractPropTypes<typeof dayViewProps>;

package/types/calendar/src/components/header/header.props.d.ts

@@ -0,0 +1,24 @@
+import { ExtractPropTypes } from 'vue';
+export declare const headerProps: {
+    activeView: {
+        Type: NumberConstructor;
+        default: number;
+    };
+    title: {
+        Type: StringConstructor;
+        default: string;
+    };
+    dailyViewTitle: {
+        Type: StringConstructor;
+        default: string;
+    };
+    weeklyViewTitle: {
+        Type: StringConstructor;
+        default: string;
+    };
+    monthlyViewTitle: {
+        Type: StringConstructor;
+        default: string;
+    };
+};
+export type HeaderProps = ExtractPropTypes<typeof headerProps>;

package/types/calendar/src/components/month/month-view.props.d.ts

@@ -0,0 +1,69 @@
+import { ExtractPropTypes } from 'vue';
+import { WeekInCalendar } from '../../types/calendar';
+import { ScheduleEvent } from '../../types/schedule';
+export declare const monthViewProps: {
+    dates: {
+        Type: {
+            (arrayLength: number): WeekInCalendar[];
+            (...items: WeekInCalendar[]): WeekInCalendar[];
+            new (arrayLength: number): WeekInCalendar[];
+            new (...items: WeekInCalendar[]): WeekInCalendar[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    daysInWeek: {
+        Type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: string[];
+    };
+    enableKeyboadNavigate: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    enableMarkCurrent: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    events: {
+        Type: {
+            (arrayLength: number): ScheduleEvent[];
+            (...items: ScheduleEvent[]): ScheduleEvent[];
+            new (arrayLength: number): ScheduleEvent[];
+            new (...items: ScheduleEvent[]): ScheduleEvent[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    activeDay: {
+        Type: ObjectConstructor;
+        default: null;
+    };
+};
+export type MonthViewProps = ExtractPropTypes<typeof monthViewProps>;

package/types/calendar/src/components/week/week-view.component.d.ts

@@ -0,0 +1,106 @@
+import { ScheduleEvent } from '../../types/schedule';
+declare const _default: import("vue").DefineComponent<{
+    daysInWeek: {
+        Type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: string[];
+    };
+    enableMarkCurrent: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    events: {
+        Type: {
+            (arrayLength: number): ScheduleEvent[];
+            (...items: ScheduleEvent[]): ScheduleEvent[];
+            new (arrayLength: number): ScheduleEvent[];
+            new (...items: ScheduleEvent[]): ScheduleEvent[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    week: {
+        Type: ObjectConstructor;
+        default: {
+            days: never[];
+            weekNumber: number;
+            year: number;
+        };
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], never, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    daysInWeek: {
+        Type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: string[];
+    };
+    enableMarkCurrent: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    events: {
+        Type: {
+            (arrayLength: number): ScheduleEvent[];
+            (...items: ScheduleEvent[]): ScheduleEvent[];
+            new (arrayLength: number): ScheduleEvent[];
+            new (...items: ScheduleEvent[]): ScheduleEvent[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    week: {
+        Type: ObjectConstructor;
+        default: {
+            days: never[];
+            weekNumber: number;
+            year: number;
+        };
+    };
+}>> & {}, {
+    week: {
+        days: never[];
+        weekNumber: number;
+        year: number;
+    };
+    events: never[];
+    enableMarkCurrent: boolean;
+    daysInWeek: string[];
+}>;
+export default _default;

package/types/calendar/src/components/week/week-view.props.d.ts

@@ -0,0 +1,51 @@
+import { ExtractPropTypes } from 'vue';
+import { ScheduleEvent } from '../../types/schedule';
+export declare const weekViewProps: {
+    daysInWeek: {
+        Type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: string[];
+    };
+    enableMarkCurrent: {
+        Type: BooleanConstructor;
+        default: boolean;
+    };
+    events: {
+        Type: {
+            (arrayLength: number): ScheduleEvent[];
+            (...items: ScheduleEvent[]): ScheduleEvent[];
+            new (arrayLength: number): ScheduleEvent[];
+            new (...items: ScheduleEvent[]): ScheduleEvent[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+    week: {
+        Type: ObjectConstructor;
+        default: {
+            days: never[];
+            weekNumber: number;
+            year: number;
+        };
+    };
+};
+export type WeekViewPropsType = ExtractPropTypes<typeof weekViewProps>;

package/types/calendar/src/composition/types.d.ts

@@ -0,0 +1,57 @@
+import { WeekInCalendar } from '../types/calendar';
+import { DateObject, Period } from '../types/common';
+import { NameOfMonths } from '../types/month';
+export interface DateFormatInfo {
+    value: string;
+    format: string;
+}
+export interface UseCompare {
+    isDateEarlier: (firstDate: DateObject, secondDate: DateObject) => boolean;
+    equal: (firstDate: DateObject, secondDate: DateObject) => boolean;
+    inPeriod: (date: DateObject, period: Period | null) => boolean;
+    isPoint: (period: Period, date: DateObject) => boolean;
+    equalOrEarlier: (firstDate: DateObject, secondDate: DateObject) => boolean;
+    isInitializedDate: (date: DateObject) => boolean;
+    isInitializedMonth: (date: DateObject) => boolean;
+    isInitializedYear: (date: DateObject) => boolean;
+    isMonthDisabledByDisableSince: (date: DateObject, disableSince: DateObject) => boolean;
+    isMonthDisabledByDisableUntil: (date: DateObject, disableUntil: DateObject) => boolean;
+    sameDay: (firstDate: DateObject, secondDate: DateObject) => boolean;
+    sameTime: (firstDate: DateObject, secondDate: DateObject) => boolean;
+}
+export interface UseDate {
+    emptyDate: () => DateObject;
+    getDate: (date: DateObject) => Date;
+    getDate2: (date: DateObject) => Date;
+    getDayNumber: (date: DateObject) => number;
+    getWeekdayIndex: (wd: string) => number;
+    getTimeInMilliseconds: (date: DateObject) => number;
+    getEpocTime: (date: DateObject) => number;
+    getNearDate: (now: DateObject, min: DateObject, max: DateObject) => DateObject;
+    getToday(): DateObject;
+}
+export interface UseEvent {
+    getKeyCodeFromEvent: (event: KeyboardEvent) => number;
+}
+export interface UseMonth {
+    daysInMonth: (month: number, year: number) => number;
+    daysInPreMonth: (month: number, year: number) => number;
+    getNextMonth: (month: number, year: number) => DateObject;
+    getPreviousMonth: (month: number, year: number) => DateObject;
+}
+export interface UseCalendar {
+    getMonthlyCalendar: (month: number, year: number, firstDayOfWeek: string) => WeekInCalendar[];
+    getWeeklyCalendar: (day: number, month: number, year: number, firstDayOfWeek: string) => WeekInCalendar;
+    getPreviousDay: (date: DateObject) => DateObject;
+    getNextDay: (date: DateObject) => DateObject;
+    getDayInPreviousWeek: (date: DateObject) => DateObject;
+    getDayInNextWeek: (date: DateObject) => DateObject;
+    getDayInPreviousMonth: (date: DateObject) => DateObject;
+    getDayInNextMonth: (date: DateObject) => DateObject;
+}
+export interface UseNumber {
+    getDayNumber: (date: DateObject) => number;
+    getNumberByValue: (df: DateFormatInfo) => number;
+    getMonthNumberByMonthName: (df: DateFormatInfo, monthLabels: NameOfMonths) => number;
+    getWeekNumber: (date: DateObject) => number;
+}

package/types/calendar/src/composition/use-calendar.d.ts

@@ -0,0 +1,2 @@
+import { UseCalendar } from './types';
+export default function useCalendar(): UseCalendar;

package/types/calendar/src/composition/use-compare.d.ts

@@ -0,0 +1,2 @@
+import { UseCompare } from './types';
+export declare function useCompare(): UseCompare;

package/types/calendar/src/composition/use-date.d.ts

@@ -0,0 +1,2 @@
+import { UseDate } from "./types";
+export declare function useDate(): UseDate;

package/types/calendar/src/composition/use-event.d.ts

@@ -0,0 +1,30 @@
+import { UseEvent } from './types';
+/**
+ * Event key codes
+ */
+export declare enum KeyCode {
+    enter = 13,
+    esc = 27,
+    space = 32,
+    leftArrow = 37,
+    upArrow = 38,
+    rightArrow = 39,
+    downArrow = 40,
+    tab = 9,
+    shift = 16
+}
+/**
+ * Event key names
+ */
+export declare enum KeyName {
+    enter = "Enter",
+    esc = "Escape",
+    space = " ",
+    leftArrow = "ArrowLeft",
+    upArrow = "ArrowUp",
+    rightArrow = "ArrowRight",
+    downArrow = "ArrowDown",
+    tab = "Tab",
+    shift = "Shift"
+}
+export declare function useEvent(): UseEvent;

package/types/calendar/src/composition/use-month.d.ts

@@ -0,0 +1,2 @@
+import { UseMonth } from './types';
+export declare function useMonth(): UseMonth;

package/types/calendar/src/types/calendar.d.ts

@@ -0,0 +1,13 @@
+import { DateObject, MonthTag } from './common';
+import { ScheduleEvent } from './schedule';
+export interface DayInCalendar {
+    date: DateObject;
+    events?: ScheduleEvent[];
+    isCurrent?: boolean;
+    monthTag: MonthTag;
+}
+export interface WeekInCalendar {
+    days: Array<DayInCalendar>;
+    weekNumber: number;
+    year: number;
+}

package/types/calendar/src/types/common.d.ts

@@ -0,0 +1,32 @@
+export interface DateObject {
+    year?: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+}
+export interface Period {
+    from: DateObject;
+    to: DateObject;
+}
+export interface MarkStatus {
+    marked: boolean;
+    color: string;
+}
+export interface MarkedDates {
+    dates: DateObject[];
+    color: string;
+}
+export type SelectMode = 'day' | 'week' | 'month' | 'year';
+export declare const weekDays: string[];
+export declare enum MonthTag {
+    previous = 1,
+    current = 2,
+    next = 3
+}
+export interface EventItem {
+    starts: DateObject;
+    ends: DateObject;
+    title: string;
+}

package/types/calendar/src/types/month-view.d.ts

@@ -0,0 +1,23 @@
+import { DateObject, EventItem, MonthTag } from './common';
+export interface CalenderMonthViewDayItem {
+    date: DateObject;
+    events?: EventItem[];
+    isCurrent?: boolean;
+    tag: MonthTag;
+}
+export interface CalendarMonthViewWeekItem {
+    days: Array<CalenderMonthViewDayItem>;
+    numberInTheYear: number;
+    year: number;
+}
+export type CalendarItemPart = 'upper' | 'lower';
+export interface CalendarWeekViewItemCell {
+    date: DateObject;
+    events: EventItem[];
+}
+export interface CalendarWeekViewItem {
+    time: DateObject;
+    cells: Array<CalendarWeekViewItemCell>;
+    title: string;
+    part: CalendarItemPart;
+}

package/types/calendar/src/types/month.d.ts

@@ -0,0 +1,20 @@
+import { DateObject } from './common';
+export interface MonthViewItem {
+    date: DateObject;
+    disable: boolean;
+    displayText: string;
+    isCurrent: boolean;
+    month: number;
+    range?: boolean;
+    selected?: boolean;
+}
+export interface ActiveMonth {
+    month: number;
+    year: number;
+    displayTextOfMonth: string;
+    displayTextOfYear: string;
+}
+export interface NameOfMonths {
+    [month: number]: string;
+}
+export declare const defaultNameOfMonths: Record<number, string>;