@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/es/datePicker/_utils/parser.js

@@ -0,0 +1,58 @@
+/**
+ * @file
+ * Various date-related analysis methods
+ */
+import { isValid, parseISO, parse } from 'date-fns';
+/**
+ * Parsing value to Date object
+ */
+
+export function compatibleParse(value, formatToken, baseDate, locale) {
+  let result = null;
+
+  if (value) {
+    if (formatToken) {
+      baseDate = baseDate || new Date();
+      result = parse(value, formatToken, baseDate, {
+        locale
+      });
+    }
+
+    if (!isValid(result)) {
+      result = parseISO(value);
+    }
+
+    if (!isValid(result)) {
+      result = new Date(Date.parse(value));
+    }
+
+    const yearInvalid = isValid(result) && String(result.getFullYear()).length > 4;
+
+    if (!isValid(result) || yearInvalid) {
+      result = null;
+    }
+  }
+
+  return result;
+}
+/**
+ * whether value can be parsed with date-fns `parse`
+ *
+ * @example
+ * isValueParseValid({ value: '2021-01-01', formatToken: 'yyyy-MM-dd' }); // true
+ * isValueParseValid({ value: '2021-01-0', formatToken: 'yyyy-MM-dd' }); // false
+ * isValueParseValid({ value: '2021-01', formatToken: 'yyyy-MM-dd' }); // false
+ */
+
+export function isValueParseValid(options) {
+  const {
+    value,
+    locale,
+    formatToken
+  } = options;
+  const baseDate = options.baseDate || new Date();
+  const result = parse(value, formatToken, baseDate, {
+    locale
+  });
+  return isValid(result);
+}

package/lib/es/datePicker/constants.d.ts

@@ -0,0 +1,53 @@
+declare const cssClasses: {
+    readonly DAY_TODAY: "semi-datepicker-day-today";
+    readonly DAY_IN_RANGE: "semi-datepicker-day-inrange";
+    readonly DAY_HOVER: "semi-datepicker-day-inhover";
+    readonly DAY_SELECTED: "semi-datepicker-day-selected";
+    readonly DAY_SELECTED_START: "semi-datepicker-day-selected-start";
+    readonly DAY_SELECTED_END: "semi-datepicker-day-selected-end";
+    readonly DAY_DISABLED: "semi-datepicker-day-disabled";
+    readonly DAY_HOVER_DAY: "semi-datepicker-day-hoverday";
+    readonly DAY_HOVER_DAY_OFFSET: "semi-datepicker-day-hoverday-offset";
+    readonly DAY_IN_OFFSET_RANGE: "semi-datepicker-day-inoffsetrange";
+    readonly DAY_SELECTED_RANGE_HOVER: "semi-datepicker-day-selectedrange-hover";
+    readonly DAY_OFFSET_RANGE_START: "semi-datepicker-day-offsetrange-start";
+    readonly DAY_OFFSET_RANGE_END: "semi-datepicker-day-offsetrange-end";
+    readonly DAY_SELECTED_START_AFTER_HOVER: "semi-datepicker-day-selected-start-afterhover";
+    readonly DAY_SELECTED_END_BEFORE_HOVER: "semi-datepicker-day-selected-end-beforehover";
+    readonly DAY_HOVER_DAY_BEFORE_RANGE: "semi-datepicker-day-hoverday-beforerange";
+    readonly DAY_HOVER_DAY_AFTER_RANGE: "semi-datepicker-day-hoverday-afterrange";
+    readonly DAY_HOVER_DAY_IN_RANGE: "semi-datepicker-day-hoverday-inrange";
+    readonly DAY_HOVER_DAY_AROUND_SINGLE_SELECTED: "semi-datepicker-day-hoverday-around-singleselected";
+    readonly PREFIX: "semi-datepicker";
+    readonly NAVIGATION: "semi-datepicker-navigation";
+    readonly PANEL_YAM: "semi-datepicker-panel-yam";
+    readonly MONTH: "semi-datepicker-month";
+    readonly WEEKDAY: "semi-datepicker-weekday";
+    readonly WEEKS: "semi-datepicker-weeks";
+    readonly WEEK: "semi-datepicker-week";
+    readonly DAY: "semi-datepicker-day";
+};
+declare const strings: {
+    readonly FORMAT_FULL_DATE: "yyyy-MM-dd";
+    readonly FORMAT_TIME_PICKER: "HH:mm:ss";
+    readonly FORMAT_DATE_TIME: "yyyy-MM-dd HH:mm:ss";
+    readonly FORMAT_YEAR_MONTH: "yyyy-MM";
+    readonly DEFAULT_SEPARATOR_MULTIPLE: ",";
+    readonly DEFAULT_SEPARATOR_RANGE: " ~ ";
+    readonly SIZE_SET: readonly ["small", "default", "large"];
+    readonly TYPE_SET: readonly ["date", "dateRange", "year", "month", "dateTime", "dateTimeRange"];
+    readonly PRESET_POSITION_SET: readonly ["left", "right", "top", "bottom"];
+    readonly DENSITY_SET: readonly ["default", "compact"];
+    readonly PANEL_TYPE_LEFT: "left";
+    readonly PANEL_TYPE_RIGHT: "right";
+    readonly STATUS: readonly ["default", "error", "warning", "success"];
+    readonly POSITION_SET: readonly ["top", "topLeft", "topRight", "left", "leftTop", "leftBottom", "right", "rightTop", "rightBottom", "bottom", "bottomLeft", "bottomRight", "leftTopOver", "rightTopOver"];
+    readonly POSITION_INLINE_INPUT: "leftTopOver";
+};
+declare const numbers: {
+    readonly WEEK_START_ON: 0;
+    readonly WEEK_HEIGHT: 36;
+    readonly SPACING: number;
+    readonly SPACING_INSET_INPUT: 1;
+};
+export { cssClasses, strings, numbers };

package/lib/es/datePicker/constants.js

@@ -0,0 +1,59 @@
+import { VALIDATE_STATUS, BASE_CLASS_PREFIX } from '../base/constants';
+import { numbers as popoverNumber, strings as POPOVER_STRINGS } from '../popover/constants';
+const dayItemClasses = {
+  DAY_TODAY: `${BASE_CLASS_PREFIX}-datepicker-day-today`,
+  DAY_IN_RANGE: `${BASE_CLASS_PREFIX}-datepicker-day-inrange`,
+  DAY_HOVER: `${BASE_CLASS_PREFIX}-datepicker-day-inhover`,
+  DAY_SELECTED: `${BASE_CLASS_PREFIX}-datepicker-day-selected`,
+  DAY_SELECTED_START: `${BASE_CLASS_PREFIX}-datepicker-day-selected-start`,
+  DAY_SELECTED_END: `${BASE_CLASS_PREFIX}-datepicker-day-selected-end`,
+  DAY_DISABLED: `${BASE_CLASS_PREFIX}-datepicker-day-disabled`,
+  DAY_HOVER_DAY: `${BASE_CLASS_PREFIX}-datepicker-day-hoverday`,
+  DAY_HOVER_DAY_OFFSET: `${BASE_CLASS_PREFIX}-datepicker-day-hoverday-offset`,
+  DAY_IN_OFFSET_RANGE: `${BASE_CLASS_PREFIX}-datepicker-day-inoffsetrange`,
+  DAY_SELECTED_RANGE_HOVER: `${BASE_CLASS_PREFIX}-datepicker-day-selectedrange-hover`,
+  DAY_OFFSET_RANGE_START: `${BASE_CLASS_PREFIX}-datepicker-day-offsetrange-start`,
+  DAY_OFFSET_RANGE_END: `${BASE_CLASS_PREFIX}-datepicker-day-offsetrange-end`,
+  DAY_SELECTED_START_AFTER_HOVER: `${BASE_CLASS_PREFIX}-datepicker-day-selected-start-afterhover`,
+  DAY_SELECTED_END_BEFORE_HOVER: `${BASE_CLASS_PREFIX}-datepicker-day-selected-end-beforehover`,
+  DAY_HOVER_DAY_BEFORE_RANGE: `${BASE_CLASS_PREFIX}-datepicker-day-hoverday-beforerange`,
+  DAY_HOVER_DAY_AFTER_RANGE: `${BASE_CLASS_PREFIX}-datepicker-day-hoverday-afterrange`,
+  DAY_HOVER_DAY_IN_RANGE: `${BASE_CLASS_PREFIX}-datepicker-day-hoverday-inrange`,
+  DAY_HOVER_DAY_AROUND_SINGLE_SELECTED: `${BASE_CLASS_PREFIX}-datepicker-day-hoverday-around-singleselected`
+};
+const cssClasses = Object.assign({
+  PREFIX: `${BASE_CLASS_PREFIX}-datepicker`,
+  NAVIGATION: `${BASE_CLASS_PREFIX}-datepicker-navigation`,
+  PANEL_YAM: `${BASE_CLASS_PREFIX}-datepicker-panel-yam`,
+  MONTH: `${BASE_CLASS_PREFIX}-datepicker-month`,
+  WEEKDAY: `${BASE_CLASS_PREFIX}-datepicker-weekday`,
+  WEEKS: `${BASE_CLASS_PREFIX}-datepicker-weeks`,
+  WEEK: `${BASE_CLASS_PREFIX}-datepicker-week`,
+  DAY: `${BASE_CLASS_PREFIX}-datepicker-day`
+}, dayItemClasses);
+const formatToken = {
+  FORMAT_FULL_DATE: 'yyyy-MM-dd',
+  FORMAT_TIME_PICKER: 'HH:mm:ss',
+  FORMAT_DATE_TIME: 'yyyy-MM-dd HH:mm:ss',
+  FORMAT_YEAR_MONTH: 'yyyy-MM'
+};
+const strings = Object.assign({
+  DEFAULT_SEPARATOR_MULTIPLE: ',',
+  DEFAULT_SEPARATOR_RANGE: ' ~ ',
+  SIZE_SET: ['small', 'default', 'large'],
+  TYPE_SET: ['date', 'dateRange', 'year', 'month', 'dateTime', 'dateTimeRange'],
+  PRESET_POSITION_SET: ['left', 'right', 'top', 'bottom'],
+  DENSITY_SET: ['default', 'compact'],
+  PANEL_TYPE_LEFT: 'left',
+  PANEL_TYPE_RIGHT: 'right',
+  STATUS: VALIDATE_STATUS,
+  POSITION_SET: POPOVER_STRINGS.POSITION_SET,
+  POSITION_INLINE_INPUT: 'leftTopOver'
+}, formatToken);
+const numbers = {
+  WEEK_START_ON: 0,
+  WEEK_HEIGHT: 36,
+  SPACING: popoverNumber.SPACING,
+  SPACING_INSET_INPUT: 1
+};
+export { cssClasses, strings, numbers };

package/lib/es/datePicker/foundation.d.ts

@@ -0,0 +1,483 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+import { strings } from './constants';
+import type { ArrayElement } from '../utils/type';
+import type { Type, DateInputFoundationProps, InsetInputValue } from './inputFoundation';
+import type { MonthsGridFoundationProps } from './monthsGridFoundation';
+import type { WeekStartNumber } from './_utils/getMonthTable';
+export declare type ValidateStatus = ArrayElement<typeof strings.STATUS>;
+export declare type InputSize = ArrayElement<typeof strings.SIZE_SET>;
+export declare type Position = ArrayElement<typeof strings.POSITION_SET>;
+export declare type PresetPosition = ArrayElement<typeof strings.PRESET_POSITION_SET>;
+export declare type BaseValueType = string | number | Date;
+export declare type DayStatusType = {
+    isToday?: boolean;
+    isSelected?: boolean;
+    isDisabled?: boolean;
+    isSelectedStart?: boolean;
+    isSelectedEnd?: boolean;
+    isInRange?: boolean;
+    isHover?: boolean;
+    isOffsetRangeStart?: boolean;
+    isOffsetRangeEnd?: boolean;
+    isHoverInOffsetRange?: boolean;
+};
+export declare type DisabledDateOptions = {
+    rangeStart?: string;
+    rangeEnd?: string;
+    /**
+     * current select of range type
+     */
+    rangeInputFocus?: 'rangeStart' | 'rangeEnd' | false;
+};
+export declare type PresetType = {
+    start?: string | Date | number;
+    end?: string | Date | number;
+    text?: string;
+};
+export declare type TriggerRenderProps = {
+    [x: string]: any;
+    value?: ValueType;
+    inputValue?: string;
+    placeholder?: string | string[];
+    autoFocus?: boolean;
+    size?: InputSize;
+    disabled?: boolean;
+    inputReadOnly?: boolean;
+    componentProps?: DatePickerFoundationProps;
+};
+export declare type DateOffsetType = (selectedDate?: Date) => Date;
+export declare type DensityType = 'default' | 'compact';
+export declare type DisabledDateType = (date?: Date, options?: DisabledDateOptions) => boolean;
+export declare type DisabledTimeType = (date?: Date | Date[], panelType?: string) => ({
+    disabledHours?: () => number[];
+    disabledMinutes?: (hour: number) => number[];
+    disabledSeconds?: (hour: number, minute: number) => number[];
+});
+export declare type OnCancelType = (date: Date | Date[], dateStr: string | string[]) => void;
+export declare type OnPanelChangeType = (date: Date | Date[], dateStr: string | string[]) => void;
+export declare type OnChangeType = (date?: Date | Date[] | string | string[], dateStr?: string | string[] | Date | Date[]) => void;
+export declare type OnConfirmType = (date: Date | Date[], dateStr: string | string[]) => void;
+export declare type OnPresetClickType = (item: PresetType, e: any) => void;
+export declare type PresetsType = Array<PresetType | (() => PresetType)>;
+export declare type RenderDateType = (dayNumber?: number, fullDate?: string) => any;
+export declare type RenderFullDateType = (dayNumber?: number, fullDate?: string, dayStatus?: DayStatusType) => any;
+export declare type TriggerRenderType = (props: TriggerRenderProps) => any;
+export declare type ValueType = BaseValueType | BaseValueType[];
+export interface ElementProps {
+    bottomSlot?: any;
+    insetLabel?: any;
+    prefix?: any;
+    topSlot?: any;
+}
+export interface RenderProps {
+    renderDate?: RenderDateType;
+    renderFullDate?: RenderFullDateType;
+    triggerRender?: TriggerRenderType;
+}
+export declare type RangeType = 'rangeStart' | 'rangeEnd' | false;
+export interface EventHandlerProps {
+    onCancel?: OnCancelType;
+    onChange?: OnChangeType;
+    onOpenChange?: (status: boolean) => void;
+    onPanelChange?: OnPanelChangeType;
+    onConfirm?: OnConfirmType;
+    onBlur?: (e: any) => void;
+    onClear?: (e: any) => void;
+    onFocus?: (e: any, rangType: RangeType) => void;
+    onPresetClick?: OnPresetClickType;
+}
+export interface DatePickerFoundationProps extends ElementProps, RenderProps, EventHandlerProps {
+    autoAdjustOverflow?: boolean;
+    autoFocus?: boolean;
+    autoSwitchDate?: boolean;
+    className?: string;
+    defaultOpen?: boolean;
+    defaultPickerValue?: ValueType;
+    defaultValue?: ValueType;
+    density?: DensityType;
+    disabled?: boolean;
+    disabledDate?: DisabledDateType;
+    disabledTime?: DisabledTimeType;
+    dropdownClassName?: string;
+    dropdownStyle?: Record<string, any>;
+    endDateOffset?: DateOffsetType;
+    format?: string;
+    getPopupContainer?: () => HTMLElement;
+    inputReadOnly?: boolean;
+    inputStyle?: Record<string, any>;
+    max?: number;
+    motion?: boolean;
+    multiple?: boolean;
+    needConfirm?: boolean;
+    onChangeWithDateFirst?: boolean;
+    open?: boolean;
+    placeholder?: string | string[];
+    position?: Position;
+    prefixCls?: string;
+    presets?: PresetsType;
+    presetPosition?: PresetPosition;
+    showClear?: boolean;
+    size?: InputSize;
+    spacing?: number;
+    startDateOffset?: DateOffsetType;
+    stopPropagation?: boolean | string;
+    style?: Record<string, any>;
+    timePickerOpts?: any;
+    timeZone?: string | number;
+    type?: Type;
+    validateStatus?: ValidateStatus;
+    value?: ValueType;
+    weekStartsOn?: WeekStartNumber;
+    zIndex?: number;
+    syncSwitchMonth?: boolean;
+    hideDisabledOptions?: MonthsGridFoundationProps['hideDisabledOptions'];
+    disabledTimePicker?: MonthsGridFoundationProps['disabledTimePicker'];
+    locale?: any;
+    dateFnsLocale?: any;
+    localeCode?: string;
+    rangeSeparator?: string;
+    insetInput?: boolean;
+    preventScroll?: boolean;
+}
+export interface DatePickerFoundationState {
+    panelShow: boolean;
+    isRange: boolean;
+    inputValue: string;
+    value: Date[];
+    cachedSelectedValue: Date[];
+    prevTimeZone: string | number;
+    rangeInputFocus: RangeType;
+    autofocus: boolean;
+    insetInputValue: InsetInputValue;
+    triggerDisabled: boolean;
+}
+export { Type, DateInputFoundationProps };
+export interface DatePickerAdapter extends DefaultAdapter<DatePickerFoundationProps, DatePickerFoundationState> {
+    togglePanel: (panelShow: boolean) => void;
+    registerClickOutSide: () => void;
+    unregisterClickOutSide: () => void;
+    notifyBlur: DatePickerFoundationProps['onBlur'];
+    notifyFocus: DatePickerFoundationProps['onFocus'];
+    notifyClear: DatePickerFoundationProps['onClear'];
+    notifyChange: DatePickerFoundationProps['onChange'];
+    notifyCancel: DatePickerFoundationProps['onCancel'];
+    notifyConfirm: DatePickerFoundationProps['onConfirm'];
+    notifyOpenChange: DatePickerFoundationProps['onOpenChange'];
+    notifyPresetsClick: DatePickerFoundationProps['onPresetClick'];
+    updateValue: (value: Date[]) => void;
+    updatePrevTimezone: (prevTimeZone: string | number) => void;
+    updateCachedSelectedValue: (cachedSelectedValue: Date[]) => void;
+    updateInputValue: (inputValue: string) => void;
+    needConfirm: () => boolean;
+    typeIsYearOrMonth: () => boolean;
+    setRangeInputFocus: (rangeInputFocus: DatePickerFoundationState['rangeInputFocus']) => void;
+    couldPanelClosed: () => boolean;
+    isEventTarget: (e: any) => boolean;
+    updateInsetInputValue: (insetInputValue: InsetInputValue) => void;
+    setInsetInputFocus: () => void;
+    setTriggerDisabled: (disabled: boolean) => void;
+}
+/**
+ * The datePicker foundation.js is responsible for maintaining the date value and the input box value, as well as the callback of both
+ *  task 1. Accept the selected date change, update the date value, and update the input box value according to the date = > Notify the change
+ *  task 2. When the input box changes, update the date value = > Notify the change
+ */
+export default class DatePickerFoundation extends BaseFoundation<DatePickerAdapter> {
+    constructor(adapter: DatePickerAdapter);
+    init(): void;
+    isValidTimeZone(timeZone?: string | number): boolean;
+    initFromProps({ value, timeZone, prevTimeZone }: Pick<DatePickerFoundationProps, 'value' | 'timeZone'> & {
+        prevTimeZone?: string | number;
+    }): void;
+    /**
+     * 如果用户传了一个空的 value，需要把 range input focus 设置为 rangeStart，这样用户可以清除完之后继续从开始选择
+     *
+     * If the user passes an empty value, you need to set the range input focus to rangeStart, so that the user can continue to select from the beginning after clearing
+     */
+    initRangeInputFocus(result: Date[]): void;
+    parseWithTimezone(value: ValueType, timeZone: string | number, prevTimeZone: string | number): Date[];
+    _isMultiple(): boolean;
+    /**
+     *
+     *  Verify and parse the following three format inputs
+     *
+        1. Date object
+        2. ISO 9601-compliant string
+        3. ts timestamp
+
+        Unified here to format the incoming value and output it as a Date object
+     *
+     */
+    _parseValue(value: BaseValueType): Date;
+    destroy(): void;
+    initPanelOpenStatus(defaultOpen?: boolean): void;
+    openPanel(): void;
+    /**
+     * do these side effects when type is dateRange or dateTimeRange
+     *   1. trigger input blur, if input value is invalid, set input value and state value to previous status
+     *   2. set cachedSelectedValue using given dates(in needConfirm mode)
+     *      - directly closePanel without click confirm will set cachedSelectedValue to state value
+     *      - select one date(which means that the selection value is incomplete) and click confirm also set cachedSelectedValue to state value
+     */
+    rangeTypeSideEffectsWhenClosePanel(inputValue: string, willUpdateDates: Date[]): void;
+    /**
+     * clear input value when selected date is not confirmed
+     */
+    needConfirmSideEffectsWhenClosePanel(willUpdateDates: Date[] | null | undefined): void;
+    /**
+     * clear inset input value when close panel
+     */
+    clearInsetInputValue(): void;
+    /**
+     * call it when change state value or input value
+     */
+    resetCachedSelectedValue(willUpdateDates?: Date[]): void;
+    /**
+     * timing to call closePanel
+     *  1. click confirm button
+     *  2. click cancel button
+     *  3. select date, time, year, month
+     *    - date type and not multiple, close panel after select date
+     *    - dateRange type, close panel after select rangeStart and rangeEnd
+     *  4. click outside
+     * @param {Event} e
+     * @param {String} inputValue
+     * @param {Date[]} dates
+     */
+    closePanel(e?: any, inputValue?: string, dates?: Date[]): void;
+    /**
+     * clear range input focus when open is controlled
+     * fixed github 1375
+     */
+    clearRangeInputFocus: () => void;
+    /**
+     * Callback when the content of the input box changes
+     * Update the date panel if the changed value is a legal date, otherwise only update the input box
+     * @param {String} input The value of the input box after the change
+     * @param {Event} e
+     */
+    handleInputChange(input: string, e: any): void;
+    /**
+     * inset input 变化时需要更新以下 state 状态
+     *  - insetInputValue（总是）
+     *  - inputValue（可以解析为合法日期时）
+     *  - value（可以解析为合法日期时）
+     */
+    handleInsetInputChange(options: {
+        insetInputStr: string;
+        format: string;
+        insetInputValue: InsetInputValue;
+    }): void;
+    /**
+     * when input change we reset cached selected value
+     */
+    _updateCachedSelectedValueFromInput(input: string): void;
+    /**
+     * Input box blur
+     * @param {String} input
+     * @param {Event} e
+     */
+    handleInputBlur(input?: string, e?: any): void;
+    /**
+     * called when range type rangeEnd input tab press
+     * @param {Event} e
+     */
+    handleRangeEndTabPress(e: any): void;
+    /**
+     * called when the input box is focused
+     * @param {Event} e input focus event
+     * @param {String} range 'rangeStart' or 'rangeEnd', use when type is range
+     */
+    handleInputFocus(e: any, range: 'rangeStart' | 'rangeEnd'): void;
+    handleSetRangeFocus(rangeInputFocus: RangeType): void;
+    handleInputClear(e: any): void;
+    /**
+     * 范围选择清除按钮回调
+     * 因为清除按钮没有集成在Input内，因此需要手动清除 value、inputValue、cachedValue
+     *
+     * callback of range input clear button
+     * Since the clear button is not integrated in Input, you need to manually clear value, inputValue, cachedValue
+     */
+    handleRangeInputClear(e: any): void;
+    handleRangeInputBlur(value: any, e: any): void;
+    handleInputComplete(input?: any): void;
+    /**
+     * Parse the input, return the time object if it is valid,
+     *  otherwise return "
+     *
+     * @param {string} input
+     * @returns  {Date [] | '}
+     */
+    parseInput(input?: string, format?: string): Date[];
+    /**
+     * get date which may include null from input
+     */
+    getLooseDateFromInput(input: string): Array<Date | null>;
+    /**
+     * parse input into `Array<Date|null>`, loose means return value includes `null`
+     *
+     * @example
+     * ```javascript
+     * parseInputLoose('2022-03-15 ~ '); // [Date, null]
+     * parseInputLoose(' ~ 2022-03-15 '); // [null, Date]
+     * parseInputLoose(''); // []
+     * parseInputLoose('2022-03- ~ 2022-0'); // [null, null]
+     * ```
+     */
+    parseInputLoose(input?: string): Array<Date | null>;
+    /**
+     * parse multiple into `Array<Date|null>`, loose means return value includes `null`
+     *
+     * @example
+     * ```javascript
+     * parseMultipleInputLoose('2021-01-01,2021-10-15'); // [Date, Date];
+     * parseMultipleInputLoose('2021-01-01,2021-10-'); // [Date, null];
+     * parseMultipleInputLoose(''); // [];
+     * ```
+     */
+    parseMultipleInputLoose(input?: string, separator?: string, needDedupe?: boolean): Date[];
+    /**
+     * Parses the input when multiple is true, if valid,
+     *  returns a list of time objects, otherwise returns an array
+     *
+     * @param {string} [input='']
+     * @param {string} [separator=',']
+     * @param {boolean} [needDedupe=false]
+     * @returns {Date[]}
+     */
+    parseMultipleInput(input?: string, separator?: string, needDedupe?: boolean): Date[];
+    /**
+     * dates[] => string
+     *
+     * @param {Date[]} dates
+     * @returns {string}
+     */
+    formatDates(dates?: Date[], customFormat?: string): string;
+    /**
+     * dates[] => string
+     *
+     * @param {Date[]} dates
+     * @returns {string}
+     */
+    formatMultipleDates(dates?: Date[], separator?: string, customFormat?: string): string;
+    /**
+     * Update date value and the value of the input box
+     * 1. Select Update
+     * 2. Input Update
+     * @param {Date|''} value
+     * @param {Boolean} forceUpdateValue
+     * @param {String} input
+     */
+    _updateValueAndInput(value: Date | Array<Date>, forceUpdateValue?: boolean, input?: string): void;
+    /**
+     * when changing the selected value through the date panel
+     * @param {*} value
+     * @param {*} options
+     */
+    handleSelectedChange(value: Date[], options?: {
+        fromPreset?: boolean;
+        needCheckFocusRecord?: boolean;
+    }): void;
+    /**
+     * when changing the year and month through the panel when the type is year or month
+     * @param {*} item
+     */
+    handleYMSelectedChange(item?: {
+        currentMonth?: number;
+        currentYear?: number;
+    }): void;
+    handleConfirm(): void;
+    handleCancel(): void;
+    handlePresetClick(item: PresetType, e: any): void;
+    /**
+     * 根据 type 处理 onChange 返回的参数
+     *
+     *  - 返回的日期需要把用户时间转换为设置的时区时间
+     *      - 用户时间：用户计算机系统时间
+     *      - 时区时间：通过 ConfigProvider 设置的 timeZone
+     *  - 例子：用户设置时区为+9，计算机所在时区为+8区，然后用户选择了22:00
+     *      - DatePicker 内部保存日期 state 为 +8 的 22:00 => a = new Date("2021-05-25 22:00:00")
+     *      - 传出去时，需要把 +8 的 22:00 => +9 的 22:00 => b = zonedTimeToUtc(a, "+09:00");
+     *
+     * According to the type processing onChange returned parameters
+     *
+     *   - the returned date needs to convert the user time to the set time zone time
+     *       - user time: user computer system time
+     *       - time zone time: timeZone set by ConfigProvider
+     *   - example: the user sets the time zone to + 9, the computer's time zone is + 8 zone, and then the user selects 22:00
+     *       - DatePicker internal save date state is + 8 22:00 = > a = new Date ("2021-05-25 22:00:00")
+     *       - when passed out, you need to + 8 22:00 = > + 9 22:00 = > b = zonedTimeToUtc (a, "+ 09:00");
+     *
+     *  e.g.
+     *  let a = new Date ("2021-05-25 22:00:00");
+     *       = > Tue May 25 2021 22:00:00 GMT + 0800 (China Standard Time)
+     *  let b = zonedTimeToUtc (a, "+ 09:00");
+     *       = > Tue May 25 2021 21:00:00 GMT + 0800 (China Standard Time)
+     *
+     * @param {Date|Date[]} value
+     * @return {{ notifyDate: Date|Date[], notifyValue: string|string[]}}
+     */
+    disposeCallbackArgs(value: Date | Date[]): {
+        notifyValue: any;
+        notifyDate: any;
+    };
+    /**
+     * Notice: Check whether the date is the same as the state value before calling
+     * @param {Date[]} value
+     */
+    _notifyChange(value: Date[]): void;
+    /**
+     * Get the date changed through the date panel or enter
+     * @param {Date[]} dates
+     * @returns {Date[]}
+     */
+    _getChangedDates(dates: Date[]): any[];
+    /**
+     * Whether a date is disabled
+     * @param {Array} value
+     */
+    _someDateDisabled(value: Date[]): boolean;
+    /**
+     * Format locale date
+     * locale get from LocaleProvider
+     * @param {Date} date
+     * @param {String} token
+     */
+    localeFormat(date: Date, token: string): string;
+    _isRangeType: () => boolean;
+    _isRangeValueComplete: (value: Date[] | Date) => boolean;
+    /**
+     * Convert computer date to UTC date
+     * Before passing the date to the user, you need to convert the date to UTC time
+     * dispose date from computer date to utc date
+     * When given timeZone prop, you should convert computer date to utc date before passing to user
+     * @param {(date: Date) => Boolean} fn
+     * @param {Date|Date[]} date
+     * @returns {Boolean}
+     */
+    disposeDateFn(fn: (date: Date, ...rest: any) => boolean, date: Date | Date[], ...rest: any[]): boolean;
+    /**
+     * Determine whether the date is disabled
+     * Whether the date is disabled
+     * @param {Date} date
+     * @returns {Boolean}
+     */
+    disabledDisposeDate(date: Date, ...rest: any[]): boolean;
+    /**
+     * Determine whether the date is disabled
+     * Whether the date time is disabled
+     * @param {Date|Date[]} date
+     * @returns {Object}
+     */
+    disabledDisposeTime(date: Date | Date[], ...rest: any[]): boolean;
+    /**
+     * Trigger wrapper needs to do two things:
+     *  1. Open Panel when clicking trigger;
+     *  2. When clicking on a child but the child does not listen to the focus event, manually trigger focus
+     *
+     * @param {Event} e
+     * @returns
+     */
+    handleTriggerWrapperClick(e: any): void;
+    handlePanelVisibleChange(visible: boolean): void;
+}