@mezzanine-ui/core 0.9.0 → 0.10.2

package/calendar/calendar.d.ts

@@ -1,12 +1,7 @@
-import { Moment } from 'moment';
 /** Types */
 export declare type CalendarMode = 'year' | 'month' | 'week' | 'day';
-/**
- * @NOTE 2021/04/13
- * we want `DateType` is given from user, but it will cause compile error now,
- * so we set to Moment as default to fix this problem. (If you have any idea, let me know)
-*/
-export declare type DateType = Moment;
+/** ISO 8601 text */
+export declare type DateType = string;
 /** Classes */
 export declare const calendarPrefix = "mzn-calendar";
 export declare const calendarBoardPrefix: string;

package/calendar/index.d.ts

@@ -1,3 +1,2 @@
-export { CalendarMethods as CalendarMethodsMoment, } from './presets/moment';
-export * from './presets/typings';
+export * from './typings';
 export * from './calendar';

package/calendar/index.js

@@ -1,2 +1 @@
-export { CalendarMethods as CalendarMethodsMoment } from './presets/moment.js';
 export { calendarBoardPrefix, calendarButtonPrefix, calendarCellPrefix, calendarClasses, calendarControlsPrefix, calendarMonths, calendarPrefix, calendarRowPrefix, calendarTwelveGridPrefix, calendarYearModuler, calendarYearsBase, getCalendarYearRange, getDefaultModeFormat, getYearRange } from './calendar.js';

package/calendar/typings.d.ts

@@ -0,0 +1,43 @@
+import { DateType } from './calendar';
+/** Method Types */
+export declare type CalendarMethods<TDateType = DateType> = {
+    /** Get date infos */
+    getNow: () => TDateType;
+    getSecond: (value: TDateType) => number;
+    getMinute: (value: TDateType) => number;
+    getHour: (value: TDateType) => number;
+    getDate: (value: TDateType) => number;
+    getWeekDay: (value: TDateType) => number;
+    getMonth: (value: TDateType) => number;
+    getYear: (value: TDateType) => number;
+    getWeekDayNames: (locale: string) => string[];
+    getMonthShortName: (value: number, locale: string) => string;
+    getMonthShortNames: (locale: string) => Readonly<string[]>;
+    /** Manipulate */
+    addDay: (value: TDateType, diff: number) => TDateType;
+    addYear: (value: TDateType, diff: number) => TDateType;
+    addMonth: (value: TDateType, diff: number) => TDateType;
+    setSecond: (value: TDateType, second: number) => TDateType;
+    setMinute: (value: TDateType, minute: number) => TDateType;
+    setHour: (value: TDateType, hour: number) => TDateType;
+    setYear: (value: TDateType, year: number) => TDateType;
+    setMonth: (value: TDateType, month: number) => TDateType;
+    setDate: (value: TDateType, date: number) => TDateType;
+    startOf: (value: TDateType, granularity: any) => TDateType;
+    /** Generate day calendar */
+    getCalendarGrid: (target: TDateType) => number[][];
+    /** Compares */
+    isBefore: (target: TDateType, comparison: TDateType) => boolean;
+    isBetween: (value: TDateType, target1: TDateType, target2: TDateType, granularity: any) => boolean;
+    isSameDate: (dateOne: TDateType, dateTwo: TDateType) => boolean;
+    isSameWeek: (dateOne: TDateType, dateTwo: TDateType) => boolean;
+    isInMonth: (target: TDateType, month: number) => boolean;
+    isDateIncluded: (date: TDateType, targets: TDateType[]) => boolean;
+    isWeekIncluded: (firstDateOfWeek: TDateType, targets: TDateType[]) => boolean;
+    isMonthIncluded: (date: TDateType, targets: TDateType[]) => boolean;
+    isYearIncluded: (date: TDateType, targets: TDateType[]) => boolean;
+    /** Format */
+    formatToString: (locale: string, date: TDateType, format: string) => string;
+    /** Parse */
+    parse: (locale: string, text: string, formats: string[]) => TDateType | undefined;
+};

package/calendarMethodsDayjs/index.d.ts

@@ -0,0 +1,3 @@
+import { CalendarMethods as CalendarMethodsType } from '../calendar/typings';
+declare const CalendarMethods: CalendarMethodsType;
+export default CalendarMethods;

package/calendarMethodsDayjs/index.js

@@ -0,0 +1,107 @@
+import dayjs from 'dayjs';
+import weekday from 'dayjs/plugin/weekday';
+import localeData from 'dayjs/plugin/localeData';
+import isBetween from 'dayjs/plugin/isBetween';
+import range from 'lodash/range';
+import chunk from 'lodash/chunk';
+
+const localeMappingTable = {
+    'en-us': 'en',
+};
+const localeMapping = (locale) => { var _a; return (_a = localeMappingTable[locale]) !== null && _a !== void 0 ? _a : locale; };
+function init() {
+    dayjs.extend(weekday);
+    dayjs.extend(localeData);
+    dayjs.extend(isBetween);
+    return true;
+}
+const CalendarMethodsDayjs = {
+    /** Get date infos */
+    getNow: () => dayjs().toISOString(),
+    getSecond: (date) => dayjs(date).second(),
+    getMinute: (date) => dayjs(date).minute(),
+    getHour: (date) => dayjs(date).hour(),
+    getDate: (date) => dayjs(date).date(),
+    getWeekDay: (date) => {
+        const clone = dayjs(date).locale('en');
+        return clone.weekday() + clone.localeData().firstDayOfWeek();
+    },
+    getMonth: (date) => dayjs(date).month(),
+    getYear: (date) => dayjs(date).year(),
+    getWeekDayNames: (locale) => {
+        return dayjs().locale(localeMapping(locale)).localeData().weekdaysMin();
+    },
+    getMonthShortName: (month, locale) => {
+        const names = CalendarMethodsDayjs.getMonthShortNames(localeMapping(locale));
+        return names[month];
+    },
+    getMonthShortNames: (locale) => {
+        return dayjs().locale(localeMapping(locale)).localeData().monthsShort();
+    },
+    /** Manipulate */
+    addDay: (date, diff) => dayjs(date).add(diff, 'day').toISOString(),
+    addYear: (date, diff) => dayjs(date).add(diff, 'year').toISOString(),
+    addMonth: (date, diff) => dayjs(date).add(diff, 'month').toISOString(),
+    setSecond: (date, second) => dayjs(date).second(second).toISOString(),
+    setMinute: (date, minute) => dayjs(date).minute(minute).toISOString(),
+    setHour: (date, hour) => dayjs(date).hour(hour).toISOString(),
+    setMonth: (date, month) => dayjs(date).month(month).toISOString(),
+    setYear: (date, year) => dayjs(date).year(year).toISOString(),
+    setDate: (date, target) => dayjs(date).date(target).toISOString(),
+    startOf: (target, granularity) => dayjs(target).startOf(granularity).toISOString(),
+    /** Generate day calendar */
+    getCalendarGrid: (target) => {
+        const lastDateOfPrevMonth = dayjs(target).subtract(1, 'month').endOf('month')
+            .date();
+        const firstDayOfCurrentMonth = dayjs(target).date(1).day();
+        const lastDateOfCurrentMonth = dayjs(target).endOf('month').date();
+        return chunk([
+            ...range(lastDateOfPrevMonth - firstDayOfCurrentMonth + 1, lastDateOfPrevMonth + 1),
+            ...range(1, lastDateOfCurrentMonth + 1),
+            ...range(1, 42 - lastDateOfCurrentMonth - firstDayOfCurrentMonth + 1),
+        ], 7);
+    },
+    /** Compares */
+    isBefore: (target, comparison) => dayjs(target).isBefore(comparison),
+    isBetween: (value, target1, target2, granularity) => dayjs(value).isBetween(target1, target2, granularity),
+    isSameDate: (dateOne, dateTwo) => dayjs(dateOne).isSame(dayjs(dateTwo), 'date'),
+    isSameWeek: (dateOne, dateTwo) => dayjs(dateOne).isSame(dayjs(dateTwo), 'week'),
+    isInMonth: (target, month) => dayjs(target).month() === month,
+    isDateIncluded: (date, targets) => targets.some((target) => dayjs(date).isSame(dayjs(target), 'day')),
+    isWeekIncluded: (firstDateOfWeek, targets) => targets.some((target) => dayjs(firstDateOfWeek).isSame(dayjs(target), 'week')),
+    isMonthIncluded: (date, targets) => targets.some((target) => dayjs(date).isSame(dayjs(target), 'month')),
+    isYearIncluded: (date, targets) => targets.some((target) => dayjs(date).isSame(dayjs(target), 'year')),
+    /** Format */
+    formatToString: (locale, date, format) => {
+        const clone = dayjs(date);
+        const result = clone.locale(localeMapping(locale));
+        return result.format(format);
+    },
+    /** Parse */
+    parse: (locale, text, formats) => {
+        for (let i = 0; i < formats.length; i += 1) {
+            let format = formats[i];
+            let formatText = text;
+            if (format.includes('wo') || format.includes('Wo')) {
+                format = format.replace(/wo/g, 'w').replace(/Wo/g, 'W');
+                const matchFormat = format.match(/[-YyMmDdHhSsWwGg]+/g);
+                const matchText = formatText.match(/[-\d]+/g);
+                if (matchFormat && matchText) {
+                    format = matchFormat.join('');
+                    formatText = matchText.join('');
+                }
+            }
+            const date = dayjs(formatText, format, localeMapping(locale), true);
+            if (date.isValid()) {
+                return date.toISOString();
+            }
+        }
+        return undefined;
+    },
+};
+const CalendarMethods = (() => {
+    init();
+    return CalendarMethodsDayjs;
+})();
+
+export { CalendarMethods as default };

package/calendarMethodsMoment/index.d.ts

@@ -0,0 +1,3 @@
+import { CalendarMethods as CalendarMethodsType } from '../calendar/typings';
+declare const CalendarMethodsMoment: CalendarMethodsType;
+export default CalendarMethodsMoment;

package/{calendar/presets/moment.js → calendarMethodsMoment/index.js}

@@ -2,25 +2,25 @@ import moment from 'moment';
 import range from 'lodash/range';
 import chunk from 'lodash/chunk';
 
-const CalendarMethods = {
+const CalendarMethodsMoment = {
     /** Get date infos */
-    getNow: () => moment(),
-    getSecond: (date) => date.second(),
-    getMinute: (date) => date.minute(),
-    getHour: (date) => date.hour(),
-    getDate: (date) => date.date(),
+    getNow: () => moment().toISOString(),
+    getSecond: (date) => moment(date).second(),
+    getMinute: (date) => moment(date).minute(),
+    getHour: (date) => moment(date).hour(),
+    getDate: (date) => moment(date).date(),
     getWeekDay: (date) => {
-        const clone = date.clone().locale('en_US');
+        const clone = moment(date).locale('en_US');
         return clone.weekday() + clone.localeData().firstDayOfWeek();
     },
-    getMonth: (date) => date.month(),
-    getYear: (date) => date.year(),
+    getMonth: (date) => moment(date).month(),
+    getYear: (date) => moment(date).year(),
     getWeekDayNames: (locale) => {
         const date = moment().locale(locale);
         return date.localeData().weekdaysMin();
     },
     getMonthShortName: (month, locale) => {
-        const names = CalendarMethods.getMonthShortNames(locale);
+        const names = CalendarMethodsMoment.getMonthShortNames(locale);
         return names[month];
     },
     getMonthShortNames: (locale) => {
@@ -29,47 +29,48 @@ const CalendarMethods = {
     },
     /** Manipulate */
     addDay: (date, diff) => {
-        const clone = date.clone();
-        return clone.add(diff, 'day');
+        const clone = moment(date);
+        return clone.add(diff, 'day').toISOString();
     },
     addYear: (date, diff) => {
-        const clone = date.clone();
-        return clone.add(diff, 'year');
+        const clone = moment(date);
+        return clone.add(diff, 'year').toISOString();
     },
     addMonth: (date, diff) => {
-        const clone = date.clone();
-        return clone.add(diff, 'month');
+        const clone = moment(date);
+        return clone.add(diff, 'month').toISOString();
     },
     setSecond: (date, second) => {
-        const clone = date.clone();
-        return clone.second(second);
+        const clone = moment(date);
+        return clone.second(second).toISOString();
     },
     setMinute: (date, minute) => {
-        const clone = date.clone();
-        return clone.minute(minute);
+        const clone = moment(date);
+        return clone.minute(minute).toISOString();
     },
     setHour: (date, hour) => {
-        const clone = date.clone();
-        return clone.hour(hour);
+        const clone = moment(date);
+        return clone.hour(hour).toISOString();
     },
     setMonth: (date, month) => {
-        const clone = date.clone();
-        return clone.month(month);
+        const clone = moment(date);
+        return clone.month(month).toISOString();
     },
     setYear: (date, year) => {
-        const clone = date.clone();
-        return clone.year(year);
+        const clone = moment(date);
+        return clone.year(year).toISOString();
     },
     setDate: (date, target) => {
-        const clone = date.clone();
-        return clone.date(target);
+        const clone = moment(date);
+        return clone.date(target).toISOString();
     },
-    startOf: (target, granularity) => target.startOf(granularity),
+    startOf: (target, granularity) => moment(target).startOf(granularity).toISOString(),
     /** Generate day calendar */
     getCalendarGrid: (target) => {
-        const lastDateOfPrevMonth = target.clone().subtract(1, 'month').endOf('month').date();
-        const firstDayOfCurrentMonth = target.clone().date(1).day();
-        const lastDateOfCurrentMonth = target.clone().endOf('month').date();
+        const lastDateOfPrevMonth = moment(target).subtract(1, 'month').endOf('month')
+            .date();
+        const firstDayOfCurrentMonth = moment(target).date(1).day();
+        const lastDateOfCurrentMonth = moment(target).endOf('month').date();
         return chunk([
             ...range(lastDateOfPrevMonth - firstDayOfCurrentMonth + 1, lastDateOfPrevMonth + 1),
             ...range(1, lastDateOfCurrentMonth + 1),
@@ -77,18 +78,18 @@ const CalendarMethods = {
         ], 7);
     },
     /** Compares */
-    isBefore: (target, comparison) => target.isBefore(comparison),
-    isBetween: (value, target1, target2, granularity) => value.isBetween(target1, target2, granularity),
-    isSameDate: (dateOne, dateTwo) => dateOne.isSame(dateTwo, 'date'),
-    isSameWeek: (dateOne, dateTwo) => dateOne.isSame(dateTwo, 'week'),
-    isInMonth: (target, month) => target.month() === month,
-    isDateIncluded: (date, targets) => targets.some((target) => date.isSame(target, 'day')),
-    isWeekIncluded: (firstDateOfWeek, targets) => targets.some((target) => firstDateOfWeek.isSame(target, 'week')),
-    isMonthIncluded: (date, targets) => targets.some((target) => date.isSame(target, 'month')),
-    isYearIncluded: (date, targets) => targets.some((target) => date.isSame(target, 'year')),
+    isBefore: (target, comparison) => moment(target).isBefore(comparison),
+    isBetween: (value, target1, target2, granularity) => moment(value).isBetween(target1, target2, granularity),
+    isSameDate: (dateOne, dateTwo) => moment(dateOne).isSame(moment(dateTwo), 'date'),
+    isSameWeek: (dateOne, dateTwo) => moment(dateOne).isSame(moment(dateTwo), 'week'),
+    isInMonth: (target, month) => moment(target).month() === month,
+    isDateIncluded: (date, targets) => targets.some((target) => moment(date).isSame(moment(target), 'day')),
+    isWeekIncluded: (firstDateOfWeek, targets) => targets.some((target) => moment(firstDateOfWeek).isSame(moment(target), 'week')),
+    isMonthIncluded: (date, targets) => targets.some((target) => moment(date).isSame(moment(target), 'month')),
+    isYearIncluded: (date, targets) => targets.some((target) => moment(date).isSame(moment(target), 'year')),
     /** Format */
     formatToString: (locale, date, format) => {
-        const clone = date.clone();
+        const clone = moment(date);
         const result = clone.locale(locale);
         return result.format(format);
     },
@@ -108,11 +109,11 @@ const CalendarMethods = {
             }
             const date = moment(formatText, format, locale, true);
             if (date.isValid()) {
-                return date;
+                return date.toISOString();
             }
         }
         return undefined;
     },
 };
 
-export { CalendarMethods };
+export { CalendarMethodsMoment as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mezzanine-ui/core",
-  "version": "0.9.0",
+  "version": "0.10.2",
   "description": "Core for mezzanine-ui",
   "author": "Mezzanine",
   "repository": {
@@ -22,8 +22,21 @@
     "build": "node ../../scripts/build.js",
     "build:clean": "node ../../scripts/cleanBuild.js"
   },
+  "peerDependencies": {
+    "dayjs": "^1.10.7",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.1"
+  },
+  "peerDependenciesMeta": {
+    "moment": {
+      "optional": true
+    },
+    "dayjs": {
+      "optional": true
+    }
+  },
   "dependencies": {
-    "@mezzanine-ui/icons": "^0.7.3",
+    "@mezzanine-ui/icons": "^0.10.2",
     "@mezzanine-ui/system": "^0.7.0",
     "tslib": "^2.1.0"
   }

package/picker/picker.d.ts

@@ -6,5 +6,5 @@ export declare const pickerClasses: {
     readonly arrowIcon: "mzn-picker__arrow-icon";
 };
 /** Types */
-export declare type RangePickerValue = undefined[] | [DateType, DateType];
-export declare type RangePickerPickingValue = RangePickerValue | [DateType] | [undefined, DateType] | [DateType, undefined];
+export declare type RangePickerValue<T = DateType> = undefined[] | [T, T];
+export declare type RangePickerPickingValue<T = DateType> = RangePickerValue | [T] | [undefined, T] | [T, undefined];

package/select/_select-styles.scss

@@ -12,6 +12,7 @@ $tags-gap: 4px !default;
 
 .#{$prefix} {
   position: relative;
+  overflow: hidden;
 
   &--full-width {
     width: 100%;
@@ -48,16 +49,37 @@ $tags-gap: 4px !default;
     }
   }
 
+  &__tags-input-wrapper {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: flex-start;
+    flex-wrap: wrap;
+
+    &--ellipsis {
+      flex-wrap: unset;
+    }
+  }
+
+  &__tags-input {
+    flex: 1;
+    min-width: 30%;
+  }
+
   &__tags {
     padding-top: $tags-container-padding;
     padding-left: $tags-container-padding;
-    width: 100%;
+    width: auto;
     max-width: calc(100% - var(--#{text-field.$prefix}-prefix-x-gap) - var(--#{text-field.$prefix}-icon-size));
     display: flex;
     flex-flow: row wrap;
     align-items: center;
     justify-self: flex-start;
 
+    &--ellipsis {
+      flex-wrap: unset;
+    }
+
     > span {
       margin-right: $tags-gap;
       margin-bottom: $tags-gap;
@@ -93,37 +115,26 @@ $tags-gap: 4px !default;
 .#{$autocomplete-prefix} {
   width: 100%;
   height: 32px;
-  margin: 4px 0 0;
-  padding: 0 16px;
+  padding: 0 12px 0 16px;
+  border: none;
   display: flex;
   align-items: center;
   justify-content: flex-start;
   background-color: palette.color(bg);
   box-sizing: border-box;
+  text-align: left;
+  cursor: pointer;
 
-  input {
+  p {
     flex: 1;
-    border: 0;
-    padding: 0;
-    outline: none;
+    margin: 0;
     color: palette.color(text-primary);
-    background-color: transparent;
 
     @include typography.variant(input2);
-
-    &::placeholder {
-      color: palette.color(action-inactive);
-    }
   }
 
   &__icon {
     font-size: 24px;
-    color: palette.color(action-inactive);
-    cursor: default;
-
-    &--active {
-      color: palette.color(primary);
-      cursor: pointer;
-    }
+    color: palette.color(text-secondary);
   }
 }

package/select/select.d.ts

@@ -12,7 +12,11 @@ export declare const selectClasses: {
     readonly hostFullWidth: "mzn-select--full-width";
     /** Trigger classes */
     readonly trigger: string;
+    readonly triggerTagsInputWrapper: `${string}__tags-input-wrapper`;
+    readonly triggerTagsInputWrapperEllipsis: `${string}__tags-input-wrapper--ellipsis`;
+    readonly triggerTagsInput: `${string}__tags-input`;
     readonly triggerTags: `${string}__tags`;
+    readonly triggerTagsEllipsis: `${string}__tags--ellipsis`;
     readonly triggerSuffixActionIcon: `${string}__suffix-action-icon`;
     readonly triggerSuffixActionIconActive: `${string}__suffix-action-icon--active`;
     /** Popper classes */
@@ -23,5 +27,4 @@ export declare const selectClasses: {
     /** AutoComplete classes */
     readonly autoComplete: string;
     readonly autoCompleteIcon: `${string}__icon`;
-    readonly autoCompleteIconActive: `${string}__icon--active`;
 };

package/select/select.js

@@ -9,7 +9,11 @@ const selectClasses = {
     hostFullWidth: `${selectPrefix}--full-width`,
     /** Trigger classes */
     trigger: selectTriggerPrefix,
+    triggerTagsInputWrapper: `${selectTriggerPrefix}__tags-input-wrapper`,
+    triggerTagsInputWrapperEllipsis: `${selectTriggerPrefix}__tags-input-wrapper--ellipsis`,
+    triggerTagsInput: `${selectTriggerPrefix}__tags-input`,
     triggerTags: `${selectTriggerPrefix}__tags`,
+    triggerTagsEllipsis: `${selectTriggerPrefix}__tags--ellipsis`,
     triggerSuffixActionIcon: `${selectTriggerPrefix}__suffix-action-icon`,
     triggerSuffixActionIconActive: `${selectTriggerPrefix}__suffix-action-icon--active`,
     /** Popper classes */
@@ -20,7 +24,6 @@ const selectClasses = {
     /** AutoComplete classes */
     autoComplete: autoCompletePrefix,
     autoCompleteIcon: `${autoCompletePrefix}__icon`,
-    autoCompleteIconActive: `${autoCompletePrefix}__icon--active`,
 };
 
 export { autoCompletePrefix, selectClasses, selectPopperPrefix, selectPrefix, selectTreePrefix, selectTriggerPrefix, treeSelectPrefix };

package/table/table.d.ts

@@ -77,6 +77,7 @@ export interface TableExpandable<SourceType> {
     expandedRowRender(record: SourceType): string | {
         dataSource: TableDataSource[];
         columns?: ExpandedTableColumn[];
+        className?: string;
     };
     rowExpandable?(record: SourceType): boolean;
     onExpand?(record: SourceType, status: boolean): void;

package/calendar/presets/moment.d.ts

@@ -1,3 +0,0 @@
-import { Moment } from 'moment';
-import { CalendarMethods as CalendarMethodsType } from './typings';
-export declare const CalendarMethods: CalendarMethodsType<Moment>;

package/calendar/presets/typings.d.ts

@@ -1,42 +0,0 @@
-/** Method Types */
-export declare type CalendarMethods<DateType> = {
-    /** Get date infos */
-    getNow: () => DateType;
-    getSecond: (value: DateType) => number;
-    getMinute: (value: DateType) => number;
-    getHour: (value: DateType) => number;
-    getDate: (value: DateType) => number;
-    getWeekDay: (value: DateType) => number;
-    getMonth: (value: DateType) => number;
-    getYear: (value: DateType) => number;
-    getWeekDayNames: (locale: string) => string[];
-    getMonthShortName: (value: number, locale: string) => string;
-    getMonthShortNames: (locale: string) => Readonly<string[]>;
-    /** Manipulate */
-    addDay: (value: DateType, diff: number) => DateType;
-    addYear: (value: DateType, diff: number) => DateType;
-    addMonth: (value: DateType, diff: number) => DateType;
-    setSecond: (value: DateType, second: number) => DateType;
-    setMinute: (value: DateType, minute: number) => DateType;
-    setHour: (value: DateType, hour: number) => DateType;
-    setYear: (value: DateType, year: number) => DateType;
-    setMonth: (value: DateType, month: number) => DateType;
-    setDate: (value: DateType, date: number) => DateType;
-    startOf: (value: DateType, granularity: any) => DateType;
-    /** Generate day calendar */
-    getCalendarGrid: (target: DateType) => number[][];
-    /** Compares */
-    isBefore: (target: DateType, comparison: DateType) => boolean;
-    isBetween: (value: DateType, target1: DateType, target2: DateType, granularity: any) => boolean;
-    isSameDate: (dateOne: DateType, dateTwo: DateType) => boolean;
-    isSameWeek: (dateOne: DateType, dateTwo: DateType) => boolean;
-    isInMonth: (target: DateType, month: number) => boolean;
-    isDateIncluded: (date: DateType, targets: DateType[]) => boolean;
-    isWeekIncluded: (firstDateOfWeek: DateType, targets: DateType[]) => boolean;
-    isMonthIncluded: (date: DateType, targets: DateType[]) => boolean;
-    isYearIncluded: (date: DateType, targets: DateType[]) => boolean;
-    /** Format */
-    formatToString: (locale: string, date: DateType, format: string) => string;
-    /** Parse */
-    parse: (locale: string, text: string, formats: string[]) => DateType | undefined;
-};