add all frontend files

node_modules/rc-picker/lib/generate/dateFns.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<Date>;
+export default generateConfig;

node_modules/rc-picker/lib/generate/dateFns.js

@@ -0,0 +1,170 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dateFns = require("date-fns");
+var locales = _interopRequireWildcard(require("date-fns/locale"));
+var getLocale = function getLocale(locale) {
+  return locales[locale] || locales[locale.replace(/_/g, '')] || locales[locale.replace(/_.*$/g, '')];
+};
+var localeParse = function localeParse(format) {
+  return format.replace(/Y/g, 'y').replace(/D/g, 'd').replace(/gggg/, 'yyyy').replace(/g/g, 'G').replace(/([Ww])o/g, 'wo');
+};
+var _parse = function parse(text, format, locale) {
+  return (0, _dateFns.parse)(text, localeParse(format), new Date(), {
+    locale: getLocale(locale)
+  });
+};
+
+/**
+ * Check if the text is a valid date considering the format and locale
+ *
+ * This is a strict check, the date string must match the format exactly.
+ * Date-fns allows some flexibility in parsing dates, for example, it will parse "30/01/2" as "30/01/002".
+ * This behavior is not desirable in our case, so we need to check if the date string matches the format exactly.
+ *
+ * @param text the date string
+ * @param format the date format to use
+ * @param locale the locale to use
+ */
+var isStrictValidDate = function isStrictValidDate(text, format, locale) {
+  var date = _parse(text, format, locale);
+  if (!(0, _dateFns.isValid)(date)) {
+    return false;
+  }
+  var formattedDate = (0, _dateFns.format)(date, format, {
+    locale: getLocale(locale)
+  });
+  return text === formattedDate;
+};
+var generateConfig = {
+  // get
+  getNow: function getNow() {
+    return new Date();
+  },
+  getFixedDate: function getFixedDate(string) {
+    return new Date(string);
+  },
+  getEndDate: function getEndDate(date) {
+    return (0, _dateFns.endOfMonth)(date);
+  },
+  getWeekDay: function getWeekDay(date) {
+    return (0, _dateFns.getDay)(date);
+  },
+  getYear: function getYear(date) {
+    return (0, _dateFns.getYear)(date);
+  },
+  getMonth: function getMonth(date) {
+    return (0, _dateFns.getMonth)(date);
+  },
+  getDate: function getDate(date) {
+    return (0, _dateFns.getDate)(date);
+  },
+  getHour: function getHour(date) {
+    return (0, _dateFns.getHours)(date);
+  },
+  getMinute: function getMinute(date) {
+    return (0, _dateFns.getMinutes)(date);
+  },
+  getSecond: function getSecond(date) {
+    return (0, _dateFns.getSeconds)(date);
+  },
+  getMillisecond: function getMillisecond(date) {
+    return (0, _dateFns.getMilliseconds)(date);
+  },
+  // set
+  addYear: function addYear(date, diff) {
+    return (0, _dateFns.addYears)(date, diff);
+  },
+  addMonth: function addMonth(date, diff) {
+    return (0, _dateFns.addMonths)(date, diff);
+  },
+  addDate: function addDate(date, diff) {
+    return (0, _dateFns.addDays)(date, diff);
+  },
+  setYear: function setYear(date, year) {
+    return (0, _dateFns.setYear)(date, year);
+  },
+  setMonth: function setMonth(date, month) {
+    return (0, _dateFns.setMonth)(date, month);
+  },
+  setDate: function setDate(date, num) {
+    return (0, _dateFns.setDate)(date, num);
+  },
+  setHour: function setHour(date, hour) {
+    return (0, _dateFns.setHours)(date, hour);
+  },
+  setMinute: function setMinute(date, minute) {
+    return (0, _dateFns.setMinutes)(date, minute);
+  },
+  setSecond: function setSecond(date, second) {
+    return (0, _dateFns.setSeconds)(date, second);
+  },
+  setMillisecond: function setMillisecond(date, millisecond) {
+    return (0, _dateFns.setMilliseconds)(date, millisecond);
+  },
+  // Compare
+  isAfter: function isAfter(date1, date2) {
+    return (0, _dateFns.isAfter)(date1, date2);
+  },
+  isValidate: function isValidate(date) {
+    return (0, _dateFns.isValid)(date);
+  },
+  locale: {
+    getWeekFirstDay: function getWeekFirstDay(locale) {
+      var clone = getLocale(locale);
+      return clone.options.weekStartsOn;
+    },
+    getWeekFirstDate: function getWeekFirstDate(locale, date) {
+      return (0, _dateFns.startOfWeek)(date, {
+        locale: getLocale(locale)
+      });
+    },
+    getWeek: function getWeek(locale, date) {
+      return (0, _dateFns.getWeek)(date, {
+        locale: getLocale(locale)
+      });
+    },
+    getShortWeekDays: function getShortWeekDays(locale) {
+      var clone = getLocale(locale);
+      return Array.from({
+        length: 7
+      }).map(function (_, i) {
+        return clone.localize.day(i, {
+          width: 'short'
+        });
+      });
+    },
+    getShortMonths: function getShortMonths(locale) {
+      var clone = getLocale(locale);
+      return Array.from({
+        length: 12
+      }).map(function (_, i) {
+        return clone.localize.month(i, {
+          width: 'abbreviated'
+        });
+      });
+    },
+    format: function format(locale, date, _format) {
+      if (!(0, _dateFns.isValid)(date)) {
+        return null;
+      }
+      return (0, _dateFns.format)(date, localeParse(_format), {
+        locale: getLocale(locale)
+      });
+    },
+    parse: function parse(locale, text, formats) {
+      for (var i = 0; i < formats.length; i += 1) {
+        var format = localeParse(formats[i]);
+        if (isStrictValidDate(text, format, locale)) {
+          return _parse(text, format, locale);
+        }
+      }
+      return null;
+    }
+  }
+};
+var _default = exports.default = generateConfig;

node_modules/rc-picker/lib/generate/dayjs.d.ts

@@ -0,0 +1,4 @@
+import type { Dayjs } from 'dayjs';
+import type { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<Dayjs>;
+export default generateConfig;

node_modules/rc-picker/lib/generate/dayjs.js

@@ -0,0 +1,240 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _weekday = _interopRequireDefault(require("dayjs/plugin/weekday"));
+var _localeData = _interopRequireDefault(require("dayjs/plugin/localeData"));
+var _weekOfYear = _interopRequireDefault(require("dayjs/plugin/weekOfYear"));
+var _weekYear = _interopRequireDefault(require("dayjs/plugin/weekYear"));
+var _advancedFormat = _interopRequireDefault(require("dayjs/plugin/advancedFormat"));
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+_dayjs.default.extend(_customParseFormat.default);
+_dayjs.default.extend(_advancedFormat.default);
+_dayjs.default.extend(_weekday.default);
+_dayjs.default.extend(_localeData.default);
+_dayjs.default.extend(_weekOfYear.default);
+_dayjs.default.extend(_weekYear.default);
+_dayjs.default.extend(function (o, c) {
+  // todo support Wo (ISO week)
+  var proto = c.prototype;
+  var oldFormat = proto.format;
+  proto.format = function f(formatStr) {
+    var str = (formatStr || '').replace('Wo', 'wo');
+    return oldFormat.bind(this)(str);
+  };
+});
+var localeMap = {
+  // ar_EG:
+  // az_AZ:
+  // bg_BG:
+  bn_BD: 'bn-bd',
+  by_BY: 'be',
+  // ca_ES:
+  // cs_CZ:
+  // da_DK:
+  // de_DE:
+  // el_GR:
+  en_GB: 'en-gb',
+  en_US: 'en',
+  // es_ES:
+  // et_EE:
+  // fa_IR:
+  // fi_FI:
+  fr_BE: 'fr',
+  // todo: dayjs has no fr_BE locale, use fr at present
+  fr_CA: 'fr-ca',
+  // fr_FR:
+  // ga_IE:
+  // gl_ES:
+  // he_IL:
+  // hi_IN:
+  // hr_HR:
+  // hu_HU:
+  hy_AM: 'hy-am',
+  // id_ID:
+  // is_IS:
+  // it_IT:
+  // ja_JP:
+  // ka_GE:
+  // kk_KZ:
+  // km_KH:
+  kmr_IQ: 'ku',
+  // kn_IN:
+  // ko_KR:
+  // ku_IQ: // previous ku in antd
+  // lt_LT:
+  // lv_LV:
+  // mk_MK:
+  // ml_IN:
+  // mn_MN:
+  // ms_MY:
+  // nb_NO:
+  // ne_NP:
+  nl_BE: 'nl-be',
+  // nl_NL:
+  // pl_PL:
+  pt_BR: 'pt-br',
+  // pt_PT:
+  // ro_RO:
+  // ru_RU:
+  // sk_SK:
+  // sl_SI:
+  // sr_RS:
+  // sv_SE:
+  // ta_IN:
+  // th_TH:
+  // tr_TR:
+  // uk_UA:
+  // ur_PK:
+  // vi_VN:
+  zh_CN: 'zh-cn',
+  zh_HK: 'zh-hk',
+  zh_TW: 'zh-tw'
+};
+var parseLocale = function parseLocale(locale) {
+  var mapLocale = localeMap[locale];
+  return mapLocale || locale.split('_')[0];
+};
+
+/* istanbul ignore next */
+var parseNoMatchNotice = function parseNoMatchNotice() {
+  // zombieJ:
+  // When user typing, its always miss match format.
+  // This check is meaningless.
+  // https://github.com/ant-design/ant-design/issues/51839
+  // noteOnce(false, 'Not match any format. Please help to fire a issue about this.');
+};
+var generateConfig = {
+  // get
+  getNow: function getNow() {
+    var now = (0, _dayjs.default)();
+    // https://github.com/ant-design/ant-design/discussions/50934
+    if (typeof now.tz === 'function') {
+      return now.tz(); // use default timezone
+    }
+    return now;
+  },
+  getFixedDate: function getFixedDate(string) {
+    return (0, _dayjs.default)(string, ['YYYY-M-DD', 'YYYY-MM-DD']);
+  },
+  getEndDate: function getEndDate(date) {
+    return date.endOf('month');
+  },
+  getWeekDay: function getWeekDay(date) {
+    var clone = date.locale('en');
+    return clone.weekday() + clone.localeData().firstDayOfWeek();
+  },
+  getYear: function getYear(date) {
+    return date.year();
+  },
+  getMonth: function getMonth(date) {
+    return date.month();
+  },
+  getDate: function getDate(date) {
+    return date.date();
+  },
+  getHour: function getHour(date) {
+    return date.hour();
+  },
+  getMinute: function getMinute(date) {
+    return date.minute();
+  },
+  getSecond: function getSecond(date) {
+    return date.second();
+  },
+  getMillisecond: function getMillisecond(date) {
+    return date.millisecond();
+  },
+  // set
+  addYear: function addYear(date, diff) {
+    return date.add(diff, 'year');
+  },
+  addMonth: function addMonth(date, diff) {
+    return date.add(diff, 'month');
+  },
+  addDate: function addDate(date, diff) {
+    return date.add(diff, 'day');
+  },
+  setYear: function setYear(date, year) {
+    return date.year(year);
+  },
+  setMonth: function setMonth(date, month) {
+    return date.month(month);
+  },
+  setDate: function setDate(date, num) {
+    return date.date(num);
+  },
+  setHour: function setHour(date, hour) {
+    return date.hour(hour);
+  },
+  setMinute: function setMinute(date, minute) {
+    return date.minute(minute);
+  },
+  setSecond: function setSecond(date, second) {
+    return date.second(second);
+  },
+  setMillisecond: function setMillisecond(date, milliseconds) {
+    return date.millisecond(milliseconds);
+  },
+  // Compare
+  isAfter: function isAfter(date1, date2) {
+    return date1.isAfter(date2);
+  },
+  isValidate: function isValidate(date) {
+    return date.isValid();
+  },
+  locale: {
+    getWeekFirstDay: function getWeekFirstDay(locale) {
+      return (0, _dayjs.default)().locale(parseLocale(locale)).localeData().firstDayOfWeek();
+    },
+    getWeekFirstDate: function getWeekFirstDate(locale, date) {
+      return date.locale(parseLocale(locale)).weekday(0);
+    },
+    getWeek: function getWeek(locale, date) {
+      return date.locale(parseLocale(locale)).week();
+    },
+    getShortWeekDays: function getShortWeekDays(locale) {
+      return (0, _dayjs.default)().locale(parseLocale(locale)).localeData().weekdaysMin();
+    },
+    getShortMonths: function getShortMonths(locale) {
+      return (0, _dayjs.default)().locale(parseLocale(locale)).localeData().monthsShort();
+    },
+    format: function format(locale, date, _format) {
+      return date.locale(parseLocale(locale)).format(_format);
+    },
+    parse: function parse(locale, text, formats) {
+      var localeStr = parseLocale(locale);
+      for (var i = 0; i < formats.length; i += 1) {
+        var format = formats[i];
+        var formatText = text;
+        if (format.includes('wo') || format.includes('Wo')) {
+          // parse Wo
+          var year = formatText.split('-')[0];
+          var weekStr = formatText.split('-')[1];
+          var firstWeek = (0, _dayjs.default)(year, 'YYYY').startOf('year').locale(localeStr);
+          for (var j = 0; j <= 52; j += 1) {
+            var nextWeek = firstWeek.add(j, 'week');
+            if (nextWeek.format('Wo') === weekStr) {
+              return nextWeek;
+            }
+          }
+          parseNoMatchNotice();
+          return null;
+        }
+        var date = (0, _dayjs.default)(formatText, format, true).locale(localeStr);
+        if (date.isValid()) {
+          return date;
+        }
+      }
+      if (text) {
+        parseNoMatchNotice();
+      }
+      return null;
+    }
+  }
+};
+var _default = exports.default = generateConfig;

node_modules/rc-picker/lib/generate/index.d.ts

@@ -0,0 +1,37 @@
+export type GenerateConfig<DateType> = {
+    getWeekDay: (value: DateType) => number;
+    getMillisecond: (value: DateType) => number;
+    getSecond: (value: DateType) => number;
+    getMinute: (value: DateType) => number;
+    getHour: (value: DateType) => number;
+    getDate: (value: DateType) => number;
+    getMonth: (value: DateType) => number;
+    getYear: (value: DateType) => number;
+    getNow: () => DateType;
+    getFixedDate: (fixed: string) => DateType;
+    getEndDate: (value: DateType) => DateType;
+    addYear: (value: DateType, diff: number) => DateType;
+    addMonth: (value: DateType, diff: number) => DateType;
+    addDate: (value: DateType, diff: number) => DateType;
+    setYear: (value: DateType, year: number) => DateType;
+    setMonth: (value: DateType, month: number) => DateType;
+    setDate: (value: DateType, date: number) => DateType;
+    setHour: (value: DateType, hour: number) => DateType;
+    setMinute: (value: DateType, minute: number) => DateType;
+    setSecond: (value: DateType, second: number) => DateType;
+    setMillisecond: (value: DateType, millisecond: number) => DateType;
+    isAfter: (date1: DateType, date2: DateType) => boolean;
+    isValidate: (date: DateType) => boolean;
+    locale: {
+        getWeekFirstDay: (locale: string) => number;
+        getWeekFirstDate: (locale: string, value: DateType) => DateType;
+        getWeek: (locale: string, value: DateType) => number;
+        format: (locale: string, date: DateType, format: string) => string;
+        /** Should only return validate date instance */
+        parse: (locale: string, text: string, formats: string[]) => DateType | null;
+        /** A proxy for getting locale with moment or other locale library */
+        getShortWeekDays?: (locale: string) => string[];
+        /** A proxy for getting locale with moment or other locale library */
+        getShortMonths?: (locale: string) => string[];
+    };
+};

node_modules/rc-picker/lib/generate/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

node_modules/rc-picker/lib/generate/luxon.d.ts

@@ -0,0 +1,4 @@
+import { DateTime } from 'luxon';
+import type { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<DateTime>;
+export default generateConfig;

node_modules/rc-picker/lib/generate/luxon.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _luxon = require("luxon");
+var weekDayFormatMap = {
+  zh_CN: 'narrow',
+  zh_TW: 'narrow'
+};
+var weekDayLengthMap = {
+  en_US: 2,
+  en_GB: 2
+};
+
+/**
+ * Normalizes part of a moment format string that should
+ * not be escaped to a luxon compatible format string.
+ *
+ * @param part string
+ * @returns string
+ */
+var normalizeFormatPart = function normalizeFormatPart(part) {
+  return part.replace(/Y/g, 'y').replace(/D/g, 'd').replace(/gg/g, 'kk').replace(/Q/g, 'q').replace(/([Ww])o/g, 'WW').replace(/A/g, 'a');
+};
+
+/**
+ * Normalizes a moment compatible format string to a luxon compatible format string
+ *
+ * @param format string
+ * @returns string
+ */
+var normalizeFormat = function normalizeFormat(format) {
+  return format
+  // moment escapes strings contained in brackets
+  .split(/[[\]]/).map(function (part, index) {
+    var shouldEscape = index % 2 > 0;
+    return shouldEscape ? part : normalizeFormatPart(part);
+  })
+  // luxon escapes strings contained in single quotes
+  .join("'");
+};
+
+/**
+ * Normalizes language tags used to luxon compatible
+ * language tags by replacing underscores with hyphen-minus.
+ *
+ * @param locale string
+ * @returns string
+ */
+var normalizeLocale = function normalizeLocale(locale) {
+  return locale.replace(/_/g, '-');
+};
+var generateConfig = {
+  // get
+  getNow: function getNow() {
+    /**
+     * The current time that can respond to tz settings is required. like `dayjs().tz()`.
+     * @see: https://github.com/ant-design/ant-design/issues/51282
+     *       https://github.com/react-component/picker/pull/878
+     */
+    return _luxon.DateTime.now();
+  },
+  getFixedDate: function getFixedDate(string) {
+    return _luxon.DateTime.fromFormat(string, 'yyyy-MM-dd');
+  },
+  getEndDate: function getEndDate(date) {
+    return date.endOf('month');
+  },
+  getWeekDay: function getWeekDay(date) {
+    return date.weekday;
+  },
+  getYear: function getYear(date) {
+    return date.year;
+  },
+  getMonth: function getMonth(date) {
+    return date.month - 1;
+  },
+  // getMonth should return 0-11, luxon month returns 1-12
+  getDate: function getDate(date) {
+    return date.day;
+  },
+  getHour: function getHour(date) {
+    return date.hour;
+  },
+  getMinute: function getMinute(date) {
+    return date.minute;
+  },
+  getSecond: function getSecond(date) {
+    return date.second;
+  },
+  getMillisecond: function getMillisecond(date) {
+    return date.millisecond;
+  },
+  // set
+  addYear: function addYear(date, diff) {
+    return date.plus({
+      year: diff
+    });
+  },
+  addMonth: function addMonth(date, diff) {
+    return date.plus({
+      month: diff
+    });
+  },
+  addDate: function addDate(date, diff) {
+    return date.plus({
+      day: diff
+    });
+  },
+  setYear: function setYear(date, year) {
+    return date.set({
+      year: year
+    });
+  },
+  setMonth: function setMonth(date, month) {
+    return date.set({
+      month: month + 1
+    });
+  },
+  // setMonth month argument is 0-11, luxon months are 1-12
+  setDate: function setDate(date, day) {
+    return date.set({
+      day: day
+    });
+  },
+  setHour: function setHour(date, hour) {
+    return date.set({
+      hour: hour
+    });
+  },
+  setMinute: function setMinute(date, minute) {
+    return date.set({
+      minute: minute
+    });
+  },
+  setSecond: function setSecond(date, second) {
+    return date.set({
+      second: second
+    });
+  },
+  setMillisecond: function setMillisecond(date, milliseconds) {
+    return date.set({
+      millisecond: milliseconds
+    });
+  },
+  // Compare
+  isAfter: function isAfter(date1, date2) {
+    return date1 > date2;
+  },
+  isValidate: function isValidate(date) {
+    return date.isValid;
+  },
+  locale: {
+    getWeekFirstDate: function getWeekFirstDate(locale, date) {
+      return date.setLocale(normalizeLocale(locale)).startOf('week');
+    },
+    getWeekFirstDay: function getWeekFirstDay(locale) {
+      return _luxon.DateTime.local().setLocale(normalizeLocale(locale)).startOf('week').weekday;
+    },
+    getWeek: function getWeek(locale, date) {
+      return date.setLocale(normalizeLocale(locale)).weekNumber;
+    },
+    getShortWeekDays: function getShortWeekDays(locale) {
+      var weekdays = _luxon.Info.weekdays(weekDayFormatMap[locale] || 'short', {
+        locale: normalizeLocale(locale)
+      });
+      var shifted = weekdays.map(function (weekday) {
+        return weekday.slice(0, weekDayLengthMap[locale]);
+      });
+
+      // getShortWeekDays should return weekday labels starting from Sunday.
+      // luxon returns them starting from Monday, so we have to shift the results.
+      shifted.unshift(shifted.pop());
+      return shifted;
+    },
+    getShortMonths: function getShortMonths(locale) {
+      return _luxon.Info.months('short', {
+        locale: normalizeLocale(locale)
+      });
+    },
+    format: function format(locale, date, _format) {
+      if (!date || !date.isValid) {
+        return null;
+      }
+      return date.setLocale(normalizeLocale(locale)).toFormat(normalizeFormat(_format));
+    },
+    parse: function parse(locale, text, formats) {
+      for (var i = 0; i < formats.length; i += 1) {
+        var normalizedFormat = normalizeFormat(formats[i]);
+        var date = _luxon.DateTime.fromFormat(text, normalizedFormat, {
+          locale: normalizeLocale(locale)
+        });
+        if (date.isValid) {
+          return date;
+        }
+      }
+      return null;
+    }
+  }
+};
+var _default = exports.default = generateConfig;

node_modules/rc-picker/lib/generate/moment.d.ts

@@ -0,0 +1,4 @@
+import type { Moment } from 'moment';
+import type { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<Moment>;
+export default generateConfig;

node_modules/rc-picker/lib/generate/moment.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _moment = _interopRequireDefault(require("moment"));
+var _warning = require("rc-util/lib/warning");
+var generateConfig = {
+  // get
+  getNow: function getNow() {
+    return (0, _moment.default)();
+  },
+  getFixedDate: function getFixedDate(string) {
+    return (0, _moment.default)(string, 'YYYY-MM-DD');
+  },
+  getEndDate: function getEndDate(date) {
+    var clone = date.clone();
+    return clone.endOf('month');
+  },
+  getWeekDay: function getWeekDay(date) {
+    var clone = date.clone().locale('en_US');
+    return clone.weekday() + clone.localeData().firstDayOfWeek();
+  },
+  getYear: function getYear(date) {
+    return date.year();
+  },
+  getMonth: function getMonth(date) {
+    return date.month();
+  },
+  getDate: function getDate(date) {
+    return date.date();
+  },
+  getHour: function getHour(date) {
+    return date.hour();
+  },
+  getMinute: function getMinute(date) {
+    return date.minute();
+  },
+  getSecond: function getSecond(date) {
+    return date.second();
+  },
+  getMillisecond: function getMillisecond(date) {
+    return date.millisecond();
+  },
+  // set
+  addYear: function addYear(date, diff) {
+    var clone = date.clone();
+    return clone.add(diff, 'year');
+  },
+  addMonth: function addMonth(date, diff) {
+    var clone = date.clone();
+    return clone.add(diff, 'month');
+  },
+  addDate: function addDate(date, diff) {
+    var clone = date.clone();
+    return clone.add(diff, 'day');
+  },
+  setYear: function setYear(date, year) {
+    var clone = date.clone();
+    return clone.year(year);
+  },
+  setMonth: function setMonth(date, month) {
+    var clone = date.clone();
+    return clone.month(month);
+  },
+  setDate: function setDate(date, num) {
+    var clone = date.clone();
+    return clone.date(num);
+  },
+  setHour: function setHour(date, hour) {
+    var clone = date.clone();
+    return clone.hour(hour);
+  },
+  setMinute: function setMinute(date, minute) {
+    var clone = date.clone();
+    return clone.minute(minute);
+  },
+  setSecond: function setSecond(date, second) {
+    var clone = date.clone();
+    return clone.second(second);
+  },
+  setMillisecond: function setMillisecond(date, millisecond) {
+    var clone = date.clone();
+    return clone.millisecond(millisecond);
+  },
+  // Compare
+  isAfter: function isAfter(date1, date2) {
+    return date1.isAfter(date2);
+  },
+  isValidate: function isValidate(date) {
+    return date.isValid();
+  },
+  locale: {
+    getWeekFirstDay: function getWeekFirstDay(locale) {
+      var date = (0, _moment.default)().locale(locale);
+      return date.localeData().firstDayOfWeek();
+    },
+    getWeekFirstDate: function getWeekFirstDate(locale, date) {
+      var clone = date.clone();
+      var result = clone.locale(locale);
+      return result.weekday(0);
+    },
+    getWeek: function getWeek(locale, date) {
+      var clone = date.clone();
+      var result = clone.locale(locale);
+      return result.week();
+    },
+    getShortWeekDays: function getShortWeekDays(locale) {
+      var date = (0, _moment.default)().locale(locale);
+      return date.localeData().weekdaysMin();
+    },
+    getShortMonths: function getShortMonths(locale) {
+      var date = (0, _moment.default)().locale(locale);
+      return date.localeData().monthsShort();
+    },
+    format: function format(locale, date, _format) {
+      var clone = date.clone();
+      var result = clone.locale(locale);
+      return result.format(_format);
+    },
+    parse: function parse(locale, text, formats) {
+      var fallbackFormatList = [];
+      for (var i = 0; i < formats.length; i += 1) {
+        var format = formats[i];
+        var formatText = text;
+        if (format.includes('wo') || format.includes('Wo')) {
+          format = format.replace(/wo/g, 'w').replace(/Wo/g, 'W');
+          var matchFormat = format.match(/[-YyMmDdHhSsWwGg]+/g);
+          var matchText = formatText.match(/[-\d]+/g);
+          if (matchFormat && matchText) {
+            format = matchFormat.join('');
+            formatText = matchText.join('');
+          } else {
+            fallbackFormatList.push(format.replace(/o/g, ''));
+          }
+        }
+        var date = (0, _moment.default)(formatText, format, locale, true);
+        if (date.isValid()) {
+          return date;
+        }
+      }
+
+      // Fallback to fuzzy matching, this should always not reach match or need fire a issue
+      for (var _i = 0; _i < fallbackFormatList.length; _i += 1) {
+        var _date = (0, _moment.default)(text, fallbackFormatList[_i], locale, false);
+
+        /* istanbul ignore next */
+        if (_date.isValid()) {
+          (0, _warning.noteOnce)(false, 'Not match any format strictly and fallback to fuzzy match. Please help to fire a issue about this.');
+          return _date;
+        }
+      }
+      return null;
+    }
+  }
+};
+var _default = exports.default = generateConfig;