shineout 1.12.2 → 1.12.3

package/esm/DatePicker/utils.d.ts

@@ -0,0 +1,68 @@
+import { DateTimeType } from './Props';
+import { DateMode } from './Props';
+interface DateOptions {
+    timeZone?: string;
+    weekStartsOn?: number;
+}
+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 isValid(date: DateTimeType): 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 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): Date;
+declare function cloneTime(date: Date, old: Date, 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 | Function, options: DateOptions): any;
+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;
+    compareDay: typeof compareDay;
+    compareQuarter: typeof compareQuarter;
+    getDaysOfMonth: typeof getDaysOfMonth;
+    format: typeof formatted;
+    isInvalid: typeof isInvalid;
+    isSameDay: typeof isSameDay;
+    isSameMonth: typeof isSameMonth;
+    isSameWeek: typeof isSameWeek;
+    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;
+};
+export default _default;

package/esm/DatePicker/utils.js

@@ -0,0 +1,419 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import dayjs from 'dayjs';
+import zonedTimeToUtc from 'date-fns-tz/zonedTimeToUtc';
+import utcToZonedTime from 'date-fns-tz/utcToZonedTime';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import weekday from 'dayjs/plugin/weekday';
+import weekYear from 'dayjs/plugin/weekYear';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import enLocale from 'dayjs/locale/en';
+
+var en2Locate = _objectSpread({}, enLocale, {
+  name: 'en2',
+  weekStart: 1
+});
+
+dayjs.locale(en2Locate, undefined, true);
+dayjs.extend(advancedFormat);
+dayjs.extend(isoWeek);
+dayjs.extend(relativeTime);
+dayjs.extend(weekday);
+dayjs.extend(weekOfYear);
+dayjs.extend(weekYear);
+dayjs.extend(customParseFormat);
+dayjs.extend(quarterOfYear);
+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',
+    II: 'WW'
+  };
+  var result = fmt;
+  Object.keys(trans).forEach(function (key) {
+    result = result.replace(new RegExp(key, 'g'), trans[key]);
+  });
+  return result;
+};
+
+function getDayJsLocate(options) {
+  if (options && options.weekStartsOn === 1) return 'en2';
+  return 'en';
+} // function transDateWithZone(dd: Date, options: DateOptions, back?: boolean): Date
+// function transDateWithZone(dd: DateTimeType, options: DateOptions, back?: boolean): DateTimeType
+
+
+function transDateWithZone(dd, options, back) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  if (back === void 0) {
+    back = false;
+  }
+
+  if (options.timeZone) {
+    var timezoneHH = /^([+-]\d{2})$/; // 只放开两位时区
+
+    if (timezoneHH.test(options.timeZone)) {
+      var num = +options.timeZone;
+
+      if (num <= 13 && num >= -12) {
+        return back ? zonedTimeToUtc(dd, options.timeZone) : utcToZonedTime(dd, options.timeZone);
+      }
+    }
+
+    console.error(new Error("timeZone is not supported: " + options.timeZone));
+  }
+
+  return dd;
+}
+
+function addDays(date, offset, options) {
+  var zd = transDateWithZone(date, options);
+  var d = dayjs(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 = dayjs(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 = dayjs(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 = dayjs(zd).add(offset, 'year').toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+
+function changeDate(date, type, num, options) {
+  var zd = transDateWithZone(date, options); // type is year month ...
+
+  var d = dayjs(zd)[type](num).toDate();
+  var ud = transDateWithZone(d, options, true);
+  return ud;
+}
+
+function getDateInfo(date, type, options) {
+  var zd = transDateWithZone(date, options);
+  return dayjs(zd)[type]();
+}
+
+function compareAsc(dateA, dateB) {
+  if (!dateA || !dateB) return NaN;
+  var a = dayjs(dateA).valueOf();
+  var b = dayjs(dateB).valueOf();
+  if (!a || !b) return NaN;
+  if (a === b) return 0;
+  return a > b ? 1 : -1;
+}
+
+function format(date, fmt, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  if (!date) return 'Invalid Date';
+  var fmt2 = compatibleFmt(fmt);
+  var zd = date;
+
+  if (fmt2 !== 'X' && fmt2 !== 'x') {
+    zd = transDateWithZone(date, options);
+  }
+
+  var dd = dayjs(zd).locale(getDayJsLocate(options));
+  var result = dd.format(fmt2);
+  return result;
+}
+
+function isSameMonth(date1, date2, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  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 isValid(date) {
+  if (!date) return false;
+  if (!(date instanceof Date)) return false;
+  return dayjs(date).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 = dayjs(year + "-06-15", 'YYYY-MM-dd').locale(getDayJsLocate(options)).isoWeek(Number(week)).toDate();
+
+    return transDateWithZone(_result, options, true);
+  } // handle Quarter
+
+
+  var quarterIndex = fmt2.indexOf('Q');
+
+  if (quarterIndex >= 0 && typeof date === 'string') {
+    var quarter = date.slice(quarterIndex, quarterIndex + 2);
+
+    var _result2 = dayjs(date, fmt2).locale(getDayJsLocate(options)).quarter(Number(quarter)).toDate();
+
+    return transDateWithZone(_result2, 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 = dayjs(date, fmt2, getDayJsLocate(options)).toDate();
+  return transDateWithZone(result, options, true);
+}
+
+function toDate(day, options) {
+  if (!day) return new Date('');
+  if (day instanceof Date) return dayjs(day).toDate();
+  if (typeof day === 'number') return new Date(day);
+  if (typeof day === 'string') return transDateWithZone(dayjs(day).toDate(), options, true);
+  return dayjs(day).toDate();
+}
+
+function getDaysOfMonth(dirtyDate, options) {
+  var date = toDate(dirtyDate, options);
+  var temp = dayjs(transDateWithZone(date, options));
+  var current = dayjs(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, pad, options) {
+  if (pad === void 0) {
+    pad = 0;
+  }
+
+  if (!dateLeft || !dateRight) return NaN;
+  var left = dayjs(transDateWithZone(dateLeft, options)).startOf('date').toDate();
+  var right = dayjs(transDateWithZone(dateRight, options)).startOf('date').add(pad, 'day').toDate();
+  return compareAsc(left, right);
+}
+
+function compareMonth(dateLeft, dateRight, pad, options) {
+  if (pad === void 0) {
+    pad = 0;
+  }
+
+  if (!dateLeft || !dateRight) return 0;
+  var left = dayjs(transDateWithZone(dateLeft, options)).startOf('month').toDate();
+  var right = dayjs(transDateWithZone(dateRight, options)).startOf('month').add(pad, 'month').toDate();
+  return compareAsc(left, right);
+}
+
+function compareYear(dateLeft, dateRight, pad, options) {
+  if (pad === void 0) {
+    pad = 0;
+  }
+
+  if (!dateLeft || !dateRight) return 0;
+  var left = dayjs(transDateWithZone(dateLeft, options)).startOf('year').toDate();
+  var right = dayjs(transDateWithZone(dateRight, options)).startOf('year').add(pad, 'year').toDate();
+  return compareAsc(left, right);
+}
+
+function compareQuarter(dateLeft, dateRight, pad, options) {
+  if (pad === void 0) {
+    pad = 0;
+  }
+
+  if (!dateLeft || !dateRight) return 0;
+  var left = dayjs(transDateWithZone(dateLeft, options)).startOf('quarter').toDate();
+  var right = dayjs(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 = dayjs(zd).startOf('date').toDate();
+  var ud = transDateWithZone(dd, options, true);
+  return ud;
+}
+
+function setTime(date, old) {
+  date.setHours(old.getHours());
+  date.setMinutes(old.getMinutes());
+  date.setSeconds(old.getSeconds());
+  date.setMilliseconds(old.getMilliseconds());
+  return date;
+}
+
+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);
+}
+
+function formatDateWithDefaultTime(date, value, defaultTime, fmt, options) {
+  if (!date) return date;
+  if (value) return setTime(date, value);
+  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 = dayjs(zd).startOf('date').toDate();
+  var ud = transDateWithZone(dd, options, true);
+  return ud;
+}
+
+function compareDateArray(arr1, arr2, type, options) {
+  if (type === void 0) {
+    type = 'date';
+  }
+
+  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, 'RRRR II', options) === format(arr2[i], 'RRRR II', 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("" + 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) {
+  if (typeof fmt === 'function') return fmt(date);
+  return format(date, fmt, options);
+}
+
+export default {
+  clearHMS: clearHMS,
+  addDays: addDays,
+  addMonths: addMonths,
+  addYears: addYears,
+  addSeconds: addSeconds,
+  cloneTime: cloneTime,
+  compareAsc: compareAsc,
+  compareMonth: compareMonth,
+  compareDay: compareDay,
+  compareQuarter: compareQuarter,
+  getDaysOfMonth: getDaysOfMonth,
+  format: formatted,
+  isInvalid: isInvalid,
+  isSameDay: isSameDay,
+  isSameMonth: isSameMonth,
+  isSameWeek: isSameWeek,
+  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
+};

package/esm/DatePicker/value.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { DatePickerPropsWidthAbsolute, DatePickerValue as DatePickerValueType, QuickSelectType, DatePickerPropsWidthValue } from './Props';
+interface DatePickerState {
+    value: DatePickerValueType;
+    quickSelect?: QuickSelectType | null;
+}
+declare const _default: <T extends DatePickerValueType>(Origin: React.ComponentType<import("./Props").ContainerProps<T>>) => {
+    new (props: DatePickerPropsWidthValue<T>): {
+        componentDidMount(): void;
+        shouldComponentUpdate(nextProps: DatePickerPropsWidthValue, nextState: DatePickerState): boolean;
+        componentDidUpdate(prevProps: DatePickerPropsWidthValue): void;
+        getOptions(): {
+            timeZone: string | undefined;
+            weekStartsOn: any;
+        };
+        getFormat(): string;
+        rangeWithSingle(): boolean | 0 | undefined;
+        convertValue(value: DatePickerValueType): any;
+        handleChange(value: DatePickerValueType, callback?: (() => void) | undefined, quickSelect?: QuickSelectType<Date[]> | undefined): void;
+        handleBlur(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof DatePickerState>(state: DatePickerState | ((prevState: Readonly<DatePickerState>, props: Readonly<DatePickerPropsWidthValue<T>>) => DatePickerState | Pick<DatePickerState, K> | null) | Pick<DatePickerState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<DatePickerPropsWidthValue<T>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<DatePickerState>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<DatePickerPropsWidthValue<T>>, prevState: Readonly<DatePickerState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<DatePickerPropsWidthValue<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DatePickerPropsWidthValue<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<DatePickerPropsWidthValue<T>>, nextState: Readonly<DatePickerState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<DatePickerPropsWidthValue<T>>, nextState: Readonly<DatePickerState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;