@sheinx/hooks 3.0.0-alpha.1

package/cjs/components/use-datepicker/use-year.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.from.js");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _util = _interopRequireDefault(require("./util"));
+var _useLatestObj = _interopRequireDefault(require("../../common/use-latest-obj"));
+var _usePersistFn = _interopRequireDefault(require("../../common/use-persist-fn"));
+var useYear = function useYear(props) {
+  var options = props.options;
+  var _useState = (0, _react.useState)(props.defaultCurrent || new Date()),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    currentState = _useState2[0],
+    setCurrentState = _useState2[1];
+  var _useRef = (0, _react.useRef)({
+      cachedYear: undefined,
+      cachedYears: []
+    }),
+    context = _useRef.current;
+  var current = props.current === undefined ? currentState : props.current;
+  var startYear = _util.default.getStartYear(current, options);
+  var setCurrent = function setCurrent(date) {
+    var _props$onCurrentChang2;
+    if (props.current !== undefined) {
+      var _props$onCurrentChang;
+      (_props$onCurrentChang = props.onCurrentChange) === null || _props$onCurrentChang === void 0 ? void 0 : _props$onCurrentChang.call(props, date);
+    } else {
+      setCurrentState(date);
+    }
+    (_props$onCurrentChang2 = props.onCurrentChange) === null || _props$onCurrentChang2 === void 0 ? void 0 : _props$onCurrentChang2.call(props, date);
+  };
+  var isNow = function isNow(date) {
+    var today = _util.default.newDate(undefined, options);
+    return _util.default.isSameYear(date, today, options);
+  };
+  var getYears = function getYears() {
+    if (!current) return context.cachedYears;
+    if (context.cachedYear && context.cachedYear === startYear && context.cachedYears.length) {
+      return context.cachedYears;
+    }
+    var startDate = _util.default.parse("".concat(startYear - 1), 'YYYY', options);
+    context.cachedYear = startYear;
+    context.cachedYears = Array.from({
+      length: 12
+    }).map(function (_, index) {
+      return _util.default.addYears(startDate, index, options);
+    });
+    return context.cachedYears;
+  };
+  var handleNext = (0, _usePersistFn.default)(function () {
+    var date = _util.default.addYears(current, 10, options);
+    setCurrent(date);
+  });
+  var handlePrev = (0, _usePersistFn.default)(function () {
+    var date = _util.default.addYears(current, -10, options);
+    setCurrent(date);
+  });
+  var isDisabled = function isDisabled(date) {
+    var min = props.min,
+      max = props.max,
+      disabled = props.disabled;
+    var isDis = disabled && typeof disabled === 'function' ? disabled(date) : false;
+    if (min && _util.default.compareYear(date, min, 0, options) < 0) isDis = true;
+    if (max && _util.default.compareYear(date, max, 0, options) > 0) isDis = true;
+    return isDis;
+  };
+  var isActive = function isActive(date) {
+    if (!props.value) return false;
+    return _util.default.isSameYear(date, props.value, options);
+  };
+  var getYearStr = function getYearStr(date) {
+    return _util.default.getDateInfo(date, 'year', options);
+  };
+  var handleYearClick = function handleYearClick(date) {
+    var _props$onChange;
+    if (isDisabled(date)) return;
+    var newDate = _util.default.toDate(date);
+    (_props$onChange = props.onChange) === null || _props$onChange === void 0 ? void 0 : _props$onChange.call(props, newDate);
+    setCurrent(newDate);
+  };
+  var isInRange = function isInRange(date) {
+    var _ref = props.rangeDate || [],
+      _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+      start = _ref2[0],
+      end = _ref2[1];
+    if (!start || !end) return false;
+    var compareStart = _util.default.compareYear(date, start, 0, options);
+    var compareEnd = _util.default.compareYear(date, end, 0, options);
+    if (compareStart === 0 && compareEnd === 0) return 'start-end';
+    if (compareStart === 0) return 'start';
+    if (compareEnd === 0) return 'end';
+    if (compareStart > 0 && compareEnd < 0) return 'in';
+    return false;
+  };
+  var func = (0, _useLatestObj.default)({
+    handleNext: handleNext,
+    handlePrev: handlePrev,
+    getYears: getYears,
+    isNow: isNow,
+    isDisabled: isDisabled,
+    isActive: isActive,
+    isInRange: isInRange,
+    handleYearClick: handleYearClick,
+    getYearStr: getYearStr
+  });
+  var currentMonth = _util.default.getDateInfo(current, 'month', options) + 1;
+  return {
+    current: current,
+    currentStart: startYear,
+    currentEnd: startYear + 9,
+    currentMonth: currentMonth,
+    func: func
+  };
+};
+var _default = useYear;
+exports.default = _default;

package/cjs/components/use-datepicker/use-year.type.d.ts

@@ -0,0 +1,16 @@
+export interface UseYearProps {
+    current?: Date;
+    rangeDate?: Array<Date | undefined>;
+    defaultCurrent?: Date;
+    onCurrentChange?: (date: Date) => void;
+    value?: Date;
+    onChange?: (date: Date) => void;
+    min?: Date;
+    max?: Date;
+    disabled?: boolean | ((date: Date) => boolean);
+    options: {
+        timeZone?: string;
+        weekStartsOn?: number;
+    };
+}
+//# sourceMappingURL=use-year.type.d.ts.map

package/cjs/components/use-datepicker/use-year.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-year.type.d.ts","sourceRoot":"","sources":["use-year.type.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,SAAS,CAAC,EAAE,KAAK,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;IACpC,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACvC,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAChC,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,GAAG,CAAC,EAAE,IAAI,CAAC;IAEX,QAAQ,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC;IAC/C,OAAO,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH"}

package/cjs/components/use-datepicker/use-year.type.js

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

package/cjs/components/use-datepicker/util.d.ts

@@ -0,0 +1,82 @@
+export declare type DateTimeType = Date | number | string | undefined;
+export declare type Mode = 'year' | 'month' | 'quarter' | 'time' | 'day' | 'minute' | 'second' | 'hour' | 'week';
+export declare type DateMode = Mode | 'date' | 'weekday';
+interface DateOptions {
+    timeZone?: string;
+    weekStartsOn?: number;
+}
+export declare const compatibleFmt: (fmt?: string) => string | undefined;
+declare function transDateWithZone(dd: Date, options?: DateOptions, back?: boolean): Date;
+declare function addDays(date: Date, offset: number, options: DateOptions): Date;
+declare function addMonths(date: Date, offset: number, options: DateOptions): Date;
+declare function addSeconds(date: Date, offset: number, options: DateOptions): Date;
+declare function addYears(date: Date, offset: number, options: DateOptions): Date;
+declare function changeDate(date: Date, type: DateMode, num: number, options: DateOptions): Date;
+declare function getDateInfo(date: Date, type: DateMode, options: DateOptions): number;
+declare function compareAsc(dateA: DateTimeType, dateB: DateTimeType): number;
+declare function isSameMonth(date1: Date, date2: Date, options?: DateOptions): boolean;
+declare function isSameDay(date1: Date, date2: Date, options: DateOptions): boolean;
+declare function isSameWeek(date1: Date, date2: Date, options: DateOptions): boolean;
+declare function isSameQuarter(date1: Date, date2: Date, options: DateOptions): boolean;
+declare function isSameYear(date1: Date, date2: Date, options: DateOptions): boolean;
+declare function isValid(date: DateTimeType): boolean;
+declare function isValidString(date: string, fmt: string): boolean;
+declare function parse(d: string, fmt?: string, options?: DateOptions): Date;
+declare function toDate(day: DateTimeType, options?: DateOptions): Date;
+declare function getDaysOfMonth(dirtyDate: DateTimeType, options: DateOptions): Date[];
+declare function isInvalid(date: unknown): boolean;
+declare function toDateWithFormat(dirtyDate: DateTimeType, fmt?: string, def?: Date, options?: DateOptions): Date;
+declare function compareDay(dateLeft: Date, dateRight: Date, pad: number | undefined, options: DateOptions): number;
+declare function compareMonth(dateLeft: Date, dateRight: Date, pad: number | undefined, options: DateOptions): number;
+declare function compareWeek(dateLeft: Date, dateRight: Date, pad: number | undefined, options: DateOptions): number;
+declare function compareYear(dateLeft: Date, dateRight: Date, pad: number | undefined, options: DateOptions): number;
+declare function compareQuarter(dateLeft: Date, dateRight: Date, pad: number | undefined, options: DateOptions): number;
+declare function newDate(defaultDate?: Date | DateTimeType, options?: DateOptions): Date;
+declare function setTime(date: Date, old: Date, options?: DateOptions): Date;
+declare function cloneTime(date: Date, old: DateTimeType, fmt?: string, options?: DateOptions): Date;
+declare function formatDateWithDefaultTime(date: Date, value: Date | undefined, defaultTime: Date | undefined, fmt: string, options: DateOptions): string | Date;
+declare function clearHMS(date: Date, options: DateOptions): Date;
+declare function compareDateArray(arr1: Date[], arr2: Date[], type: string | undefined, options: DateOptions): boolean;
+declare function resetTimeByFormat(value: Date | undefined, fo: string, options: DateOptions): Date | null;
+declare function formatted(date: Date, fmt: string | ((date: Date, offsetDate: Date) => string), options: DateOptions): string;
+declare function getStartYear(date: Date, options: DateOptions): number;
+declare const _default: {
+    clearHMS: typeof clearHMS;
+    addDays: typeof addDays;
+    addMonths: typeof addMonths;
+    addYears: typeof addYears;
+    addSeconds: typeof addSeconds;
+    cloneTime: typeof cloneTime;
+    compareAsc: typeof compareAsc;
+    compareMonth: typeof compareMonth;
+    compareWeek: typeof compareWeek;
+    compareDay: typeof compareDay;
+    compareQuarter: typeof compareQuarter;
+    getDaysOfMonth: typeof getDaysOfMonth;
+    format: typeof formatted;
+    isInvalid: typeof isInvalid;
+    isSameDay: typeof isSameDay;
+    isSameMonth: typeof isSameMonth;
+    isSameWeek: typeof isSameWeek;
+    isSameYear: typeof isSameYear;
+    isSameQuarter: typeof isSameQuarter;
+    isValid: typeof isValid;
+    newDate: typeof newDate;
+    setTime: typeof setTime;
+    parse: typeof parse;
+    toDate: typeof toDate;
+    toDateWithFormat: typeof toDateWithFormat;
+    formatDateWithDefaultTime: typeof formatDateWithDefaultTime;
+    compareDateArray: typeof compareDateArray;
+    compareYear: typeof compareYear;
+    TIME_FORMAT: string;
+    resetTimeByFormat: typeof resetTimeByFormat;
+    changeDate: typeof changeDate;
+    getDateInfo: typeof getDateInfo;
+    compatibleFmt: (fmt?: string | undefined) => string | undefined;
+    transDateWithZone: typeof transDateWithZone;
+    getStartYear: typeof getStartYear;
+    isValidString: typeof isValidString;
+};
+export default _default;
+//# sourceMappingURL=util.d.ts.map

package/cjs/components/use-datepicker/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"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"}

package/cjs/components/use-datepicker/util.js

@@ -0,0 +1,405 @@
+"use strict";
+
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.compatibleFmt = void 0;
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.map.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _zonedTimeToUtc = _interopRequireDefault(require("date-fns-tz/zonedTimeToUtc"));
+var _utcToZonedTime = _interopRequireDefault(require("date-fns-tz/utcToZonedTime"));
+var _advancedFormat = _interopRequireDefault(require("dayjs/plugin/advancedFormat"));
+var _quarterOfYear = _interopRequireDefault(require("dayjs/plugin/quarterOfYear"));
+var _isoWeek = _interopRequireDefault(require("dayjs/plugin/isoWeek"));
+var _weekday = _interopRequireDefault(require("dayjs/plugin/weekday"));
+var _weekYear = _interopRequireDefault(require("dayjs/plugin/weekYear"));
+var _weekOfYear = _interopRequireDefault(require("dayjs/plugin/weekOfYear"));
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+var _relativeTime = _interopRequireDefault(require("dayjs/plugin/relativeTime"));
+var _en = _interopRequireDefault(require("dayjs/locale/en"));
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var en2Locate = _objectSpread(_objectSpread({}, _en.default), {}, {
+  name: 'en2',
+  weekStart: 1,
+  yearStart: 4
+});
+_dayjs.default.locale(en2Locate, undefined, true);
+_dayjs.default.extend(_advancedFormat.default);
+_dayjs.default.extend(_isoWeek.default);
+_dayjs.default.extend(_relativeTime.default);
+_dayjs.default.extend(_weekday.default);
+_dayjs.default.extend(_weekOfYear.default);
+_dayjs.default.extend(_weekYear.default);
+_dayjs.default.extend(_customParseFormat.default);
+_dayjs.default.extend(_quarterOfYear.default);
+var TIME_FORMAT = 'HH:mm:ss';
+var compatibleFmt = function compatibleFmt(fmt) {
+  if (typeof fmt !== 'string') return fmt;
+  var trans = {
+    yy: 'YY',
+    d: 'D',
+    a: 'A',
+    t: 'X',
+    T: 'x',
+    RRRR: 'gggg',
+    I: 'W'
+  };
+  var result = fmt;
+  Object.keys(trans).forEach(function (key) {
+    result = result.replace(new RegExp(key, 'g'), trans[key]);
+  });
+  if (result !== fmt) {
+    console.warn("invalid datepicker format: ".concat(fmt, " please use ").concat(result));
+  }
+  return result;
+};
+exports.compatibleFmt = compatibleFmt;
+function getDayJsLocate(options) {
+  if (options && options.weekStartsOn === 1) return 'en2';
+  return 'en';
+}
+function transDateWithZone(dd) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var back = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (options.timeZone) {
+    var timezoneHH = /^([+-]\d{2})$/;
+    // 只放开两位时区
+    if (timezoneHH.test(options.timeZone)) {
+      var num = +options.timeZone;
+      if (num <= 13 && num >= -12) {
+        return back ? (0, _zonedTimeToUtc.default)(dd, options.timeZone) : (0, _utcToZonedTime.default)(dd, options.timeZone);
+      }
+    }
+    console.error(new Error("timeZone is not supported: ".concat(options.timeZone)));
+  }
+  return new Date(dd);
+}
+function addDays(date, offset, options) {
+  var zd = transDateWithZone(date, options);
+  var d = (0, _dayjs.default)(zd).add(offset, 'day').toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+function addMonths(date, offset, options) {
+  var zd = transDateWithZone(date, options);
+  var d = (0, _dayjs.default)(zd).add(offset, 'month').toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+function addSeconds(date, offset, options) {
+  var zd = transDateWithZone(date, options);
+  var d = (0, _dayjs.default)(zd).add(offset, 'seconds').toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+function addYears(date, offset, options) {
+  var zd = transDateWithZone(date, options);
+  var d = (0, _dayjs.default)(zd).add(offset, 'year').toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+function changeDate(date, type, num, options) {
+  var zd = transDateWithZone(date, options);
+  var d = (0, _dayjs.default)(zd).locale(getDayJsLocate(options))[type](num).toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+function getDateInfo(date, type, options) {
+  var zd = transDateWithZone(date, options);
+  return (0, _dayjs.default)(zd)[type]();
+}
+function compareAsc(dateA, dateB) {
+  if (!dateA || !dateB) return NaN;
+  var a = (0, _dayjs.default)(dateA).valueOf();
+  var b = (0, _dayjs.default)(dateB).valueOf();
+  if (!a || !b) return NaN;
+  if (a === b) return 0;
+  return a > b ? 1 : -1;
+}
+function format(date, fmt) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!date) return 'Invalid Date';
+  var fmt2 = compatibleFmt(fmt);
+  var zd = date;
+  if (fmt2 !== 'X' && fmt2 !== 'x') {
+    zd = transDateWithZone(date, options);
+  }
+  var dd = (0, _dayjs.default)(zd).locale(getDayJsLocate(options));
+  var result = dd.format(fmt2);
+  return result;
+}
+function isSameMonth(date1, date2) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return date1 && date2 && format(date1, 'YYYY-MM', options) === format(date2, 'YYYY-MM', options);
+}
+function isSameDay(date1, date2, options) {
+  return date1 && date2 && format(date1, 'YYYY-MM-DD', options) === format(date2, 'YYYY-MM-DD', options);
+}
+function isSameWeek(date1, date2, options) {
+  if (!date1 || !date2) return false;
+  return date1 && date2 && format(date1, 'gggg-ww', options) === format(date2, 'gggg-ww', options);
+}
+function isSameQuarter(date1, date2, options) {
+  if (!date1 || !date2) return false;
+  return date1 && date2 && format(date1, 'YYYY Q', options) === format(date2, 'YYYY Q', options);
+}
+function isSameYear(date1, date2, options) {
+  if (!date1 || !date2) return false;
+  return date1 && date2 && format(date1, 'YYYY', options) === format(date2, 'YYYY', options);
+}
+function isValid(date) {
+  if (!date) return false;
+  if (!(date instanceof Date)) return false;
+  return (0, _dayjs.default)(date).isValid();
+}
+function isValidString(date, fmt) {
+  if (!date) return false;
+  return (0, _dayjs.default)(date, fmt, true).isValid();
+}
+function parse(d, fmt, options) {
+  if (!d) return new Date('');
+  // should clear[xxx]
+  var reg = /[[]([^[^\]]+?)[\]]/g;
+  var date = d && typeof d === 'string' && d.replace ? d.replace(reg, ' ') : d;
+  var fmt2 = compatibleFmt(fmt).replace(reg, ' ');
+
+  // handle IOS Year Week
+  var index = fmt2.indexOf('GGGG');
+  if (index >= 0 && typeof date === 'string') {
+    var year = date.slice(index, index + 5);
+    var weekIndex = fmt2.indexOf('WW');
+    var week = weekIndex >= 0 ? date.slice(weekIndex, weekIndex + 3) : 1;
+    var _result = (0, _dayjs.default)("".concat(year, "-06-15"), 'YYYY-MM-DD').locale(getDayJsLocate(options)).isoWeek(Number(week)).toDate();
+    return transDateWithZone(_result, options, true);
+  }
+
+  // handle IOS Year Week
+  var yearIndex = fmt2.indexOf('gggg');
+  if (yearIndex >= 0 && typeof date === 'string') {
+    var _year = date.slice(yearIndex, yearIndex + 5);
+    var _weekIndex = fmt2.indexOf('ww');
+    var _week = _weekIndex >= 0 ? date.slice(_weekIndex, _weekIndex + 3) : 1;
+    var _result2 = (0, _dayjs.default)("".concat(_year, "-06-15"), 'YYYY-MM-DD').locale(getDayJsLocate(options)).week(Number(_week)).toDate();
+    return transDateWithZone(_result2, options, true);
+  }
+  // handle Quarter
+  var quarterIndex = fmt2.indexOf('Q');
+  if (quarterIndex >= 0 && typeof date === 'string') {
+    var quarter = date.slice(quarterIndex, quarterIndex + 2);
+    var _result3 = (0, _dayjs.default)(date, fmt2).locale(getDayJsLocate(options)).quarter(Number(quarter)).toDate();
+    return transDateWithZone(_result3, options, true);
+  }
+
+  // dayjs parse stamp with  timeZone have bug
+  if (fmt2 === 'x' || fmt2 === 'X') {
+    var stamp = +date;
+    if (fmt2 === 'X') stamp *= 1000;
+    return new Date(stamp);
+  }
+  var result = (0, _dayjs.default)(date, fmt2, getDayJsLocate(options)).toDate();
+  return transDateWithZone(result, options, true);
+}
+function toDate(day, options) {
+  if (!day) return new Date('');
+  if (day instanceof Date) return (0, _dayjs.default)(day).toDate();
+  if (typeof day === 'number') return new Date(day);
+  if (typeof day === 'string') return transDateWithZone((0, _dayjs.default)(day).toDate(), options, true);
+  return (0, _dayjs.default)(day).toDate();
+}
+function getDaysOfMonth(dirtyDate, options) {
+  var date = toDate(dirtyDate, options);
+  var temp = (0, _dayjs.default)(transDateWithZone(date, options));
+  var current = (0, _dayjs.default)(transDateWithZone(date, options)).locale(getDayJsLocate(options)).startOf('month').startOf('week').hour(temp.hour()).minute(temp.minute()).second(temp.second()).millisecond(temp.millisecond());
+  var days = [];
+  var index = 0;
+  while (index < 42) {
+    days.push(transDateWithZone(current.toDate(), options, true));
+    current = current.add(1, 'day');
+    index += 1;
+  }
+  return days;
+}
+function isInvalid(date) {
+  // eslint-disable-next-line
+  return isNaN(date);
+}
+
+// function toDateWithFormat(dirtyDate: Date, fmt: string, def: DateTimeType, options: DateOptions): Date
+// function toDateWithFormat(dirtyDate: DateTimeType, fmt: string, def: DateTimeType, options: DateOptions): DateTimeType
+function toDateWithFormat(dirtyDate, fmt, def, options) {
+  var date;
+  if (typeof dirtyDate === 'string') {
+    date = parse(dirtyDate, fmt, options);
+    var str = format(date, fmt, options);
+    if (str !== dirtyDate) {
+      date = toDate(dirtyDate, options);
+    }
+  } else date = toDate(dirtyDate, options);
+  if (isInvalid(date)) date = def;
+  return date;
+}
+function compareDay(dateLeft, dateRight) {
+  var pad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  if (!dateLeft || !dateRight) return NaN;
+  var left = (0, _dayjs.default)(transDateWithZone(dateLeft, options)).startOf('date').toDate();
+  var right = (0, _dayjs.default)(transDateWithZone(dateRight, options)).startOf('date').add(pad, 'day').toDate();
+  return compareAsc(left, right);
+}
+function compareMonth(dateLeft, dateRight) {
+  var pad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  if (!dateLeft || !dateRight) return 0;
+  var left = (0, _dayjs.default)(transDateWithZone(dateLeft, options)).startOf('month').toDate();
+  var right = (0, _dayjs.default)(transDateWithZone(dateRight, options)).startOf('month').add(pad, 'month').toDate();
+  return compareAsc(left, right);
+}
+function compareWeek(dateLeft, dateRight) {
+  var pad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  if (!dateLeft || !dateRight) return 0;
+  var left = (0, _dayjs.default)(transDateWithZone(dateLeft, options)).locale(getDayJsLocate(options)).startOf('week').toDate();
+  var right = (0, _dayjs.default)(transDateWithZone(dateRight, options)).locale(getDayJsLocate(options)).startOf('week').add(pad, 'week').toDate();
+  return compareAsc(left, right);
+}
+function compareYear(dateLeft, dateRight) {
+  var pad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  if (!dateLeft || !dateRight) return 0;
+  var left = (0, _dayjs.default)(transDateWithZone(dateLeft, options)).startOf('year').toDate();
+  var right = (0, _dayjs.default)(transDateWithZone(dateRight, options)).startOf('year').add(pad, 'year').toDate();
+  return compareAsc(left, right);
+}
+function compareQuarter(dateLeft, dateRight) {
+  var pad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  if (!dateLeft || !dateRight) return 0;
+  var left = (0, _dayjs.default)(transDateWithZone(dateLeft, options)).startOf('quarter').toDate();
+  var right = (0, _dayjs.default)(transDateWithZone(dateRight, options)).startOf('quarter').add(pad, 'quarter').toDate();
+  return compareAsc(left, right);
+}
+function newDate(defaultDate, options) {
+  var date = defaultDate ? toDate(defaultDate, options) : new Date();
+  var zd = transDateWithZone(date, options);
+  var dd = (0, _dayjs.default)(zd).startOf('date').toDate();
+  var ud = transDateWithZone(dd, options, true);
+  return ud;
+}
+function setTime(date, old, options) {
+  var zd = transDateWithZone(date, options);
+  var oldZd = transDateWithZone(old, options);
+  zd.setHours(oldZd.getHours());
+  zd.setMinutes(oldZd.getMinutes());
+  zd.setSeconds(oldZd.getSeconds());
+  zd.setMilliseconds(oldZd.getMilliseconds());
+  var ud = transDateWithZone(zd, options, true);
+  return ud;
+}
+function cloneTime(date, old, fmt, options) {
+  if (!date) return date;
+  var oldDate = toDateWithFormat(old, fmt, undefined, options);
+  if (isInvalid(oldDate)) return date;
+  return setTime(date, oldDate, options);
+}
+function formatDateWithDefaultTime(date, value, defaultTime, fmt, options) {
+  if (!date) return date;
+  if (value) return setTime(date, value, options);
+  if (!defaultTime) return date;
+  var dateHMS = toDateWithFormat(defaultTime, TIME_FORMAT, undefined, options);
+  if (isInvalid(dateHMS)) return date;
+  var nDate = cloneTime(date, defaultTime, TIME_FORMAT, options);
+  return format(nDate, fmt, options);
+}
+function clearHMS(date, options) {
+  if (!isValid(date)) return date;
+  var zd = transDateWithZone(date, options);
+  var dd = (0, _dayjs.default)(zd).startOf('date').toDate();
+  var ud = transDateWithZone(dd, options, true);
+  return ud;
+}
+function compareDateArray(arr1, arr2) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'date';
+  var options = arguments.length > 3 ? arguments[3] : undefined;
+  if (!arr1 || !arr2 || arr1.length !== arr2.length) return false;
+  return arr1.every(function (v, i) {
+    if (!v || !arr2[i]) return false;
+    if (type === 'week') return format(v, 'gggg ww', options) === format(arr2[i], 'gggg ww', options);
+    return v.getTime() === arr2[i].getTime();
+  });
+}
+function getFormat(fo) {
+  var defaultFormat = 'YYYY-MM-DD HH:mm:ss.SSS';
+  ['H', 'm', 's', 'S', 'h'].map(function (v) {
+    if (fo.indexOf(v) <= -1) {
+      var reg = new RegExp("".concat(v), 'g');
+      defaultFormat = defaultFormat.replace(reg, '0');
+    }
+    return v;
+  });
+  return defaultFormat;
+}
+function resetTimeByFormat(value, fo, options) {
+  if (!value) return null;
+  var date = toDate(value, options);
+  return toDate(format(date, getFormat(fo), options), options);
+}
+function formatted(date, fmt, options) {
+  var offsetDate = transDateWithZone(date, options);
+  if (typeof fmt === 'function') return fmt(date, offsetDate);
+  return format(date, fmt, options);
+}
+function getStartYear(date, options) {
+  return Math.floor(getDateInfo(date, 'year', options) / 10) * 10;
+}
+var _default = {
+  clearHMS: clearHMS,
+  addDays: addDays,
+  addMonths: addMonths,
+  addYears: addYears,
+  addSeconds: addSeconds,
+  cloneTime: cloneTime,
+  compareAsc: compareAsc,
+  compareMonth: compareMonth,
+  compareWeek: compareWeek,
+  compareDay: compareDay,
+  compareQuarter: compareQuarter,
+  getDaysOfMonth: getDaysOfMonth,
+  format: formatted,
+  isInvalid: isInvalid,
+  isSameDay: isSameDay,
+  isSameMonth: isSameMonth,
+  isSameWeek: isSameWeek,
+  isSameYear: isSameYear,
+  isSameQuarter: isSameQuarter,
+  isValid: isValid,
+  newDate: newDate,
+  setTime: setTime,
+  parse: parse,
+  toDate: toDate,
+  toDateWithFormat: toDateWithFormat,
+  formatDateWithDefaultTime: formatDateWithDefaultTime,
+  compareDateArray: compareDateArray,
+  compareYear: compareYear,
+  TIME_FORMAT: TIME_FORMAT,
+  resetTimeByFormat: resetTimeByFormat,
+  changeDate: changeDate,
+  getDateInfo: getDateInfo,
+  compatibleFmt: compatibleFmt,
+  transDateWithZone: transDateWithZone,
+  getStartYear: getStartYear,
+  isValidString: isValidString
+};
+exports.default = _default;

package/cjs/components/use-form/Provider.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ProviderProps } from './use-form.type';
+export declare const Provider: (props: ProviderProps) => JSX.Element;
+//# sourceMappingURL=Provider.d.ts.map

package/cjs/components/use-form/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["Provider.tsx"],"names":[],"mappings":";AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,eAAO,MAAM,QAAQ,UAAW,aAAa,gBAS5C,CAAC"}