types for airbnb react-dates

This commit is contained in:
Artur-A
2017-02-12 07:40:45 +03:00
parent a01e02004b
commit e5fdb74513
3 changed files with 745 additions and 0 deletions

364
react-dates/index.d.ts vendored Normal file
View File

@@ -0,0 +1,364 @@
// Type definitions for react-dates v7.0.1
// Project: https://github.com/airbnb/react-dates
// Definitions by: Artur Ampilogov <https://github.com/Artur-A>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import moment from "moment";
import * as React from "react";
export = ReactDates;
declare namespace momentPropTypes{
type momentObj = any;
type momentString = any;
type momentDurationObj = any;
}
declare namespace ReactDates{
type AnchorDirectionShape = 'left' | 'right';
type FocusedInputShape = 'startDate' | 'endDate';
type OrientationShape = 'horizontal' | 'vertical';
type ScrollableOrientationShape = 'horizontal' | 'vertical' | 'verticalScrollable';
interface DateRangePickerShape{
startDate?: momentPropTypes.momentObj,
endDate?: momentPropTypes.momentObj,
focusedInput?: FocusedInputShape,
screenReaderInputMessage?: string,
minimumNights?: number,
isDayBlocked?: (day: any) => boolean,
isOutsideRange?: (day: any) => boolean,
enableOutsideDays?: boolean,
reopenPickerOnClearDates?: boolean,
keepOpenOnDateSelect?: boolean,
numberOfMonths?: number,
showClearDates?: boolean,
disabled?: boolean,
required?: boolean,
showDefaultInputIcon?: boolean,
orientation?: OrientationShape,
anchorDirection?: AnchorDirectionShape,
horizontalMargin?: number,
// portal options
withPortal?: boolean,
withFullScreenPortal?: boolean,
startDateId?: string,
startDatePlaceholderText?: string,
endDateId?: string,
endDatePlaceholderText?: string,
initialVisibleMonth?: () => moment.Moment,
onDatesChange?: (arg: { startDate: any, endDate: any }) => void,
onFocusChange?: (arg: FocusedInputShape) => void,
onPrevMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onNextMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
renderDay?: (day: any) => (string | JSX.Element),
// i18n
displayFormat?: (string | (()=> string)),
monthFormat?: string,
phrases?: {
closeDatePicker: string | JSX.Element,
clearDates: string | JSX.Element,
}
}
type DateRangePicker = React.ClassicComponentClass<DateRangePickerShape>;
var DateRangePicker: React.ClassicComponentClass<DateRangePickerShape>;
interface SingleDatePickerShape{
id: string,
placeholder?: string,
date?: momentPropTypes.momentObj,
focused?: boolean,
showClearDate?: boolean,
reopenPickerOnClearDates?: boolean,
keepOpenOnDateSelect?: boolean,
disabled?: boolean,
required?: boolean,
screenReaderInputMessage?: string,
onDateChange?: (date: any) => void,
onFocusChange?: (arg: { focused: boolean | null }) => void,
isDayBlocked?: (day: any) => boolean,
isOutsideRange?: (day: any) => boolean,
enableOutsideDays?: boolean,
numberOfMonths?: number,
orientation?: OrientationShape,
initialVisibleMonth?: () => moment.Moment,
anchorDirection?: AnchorDirectionShape,
horizontalMargin?: number,
navPrev?: string | JSX.Element,
navNext?: string | JSX.Element,
// portal options
withPortal?: boolean,
withFullScreenPortal?: boolean,
onPrevMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onNextMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
renderDay?: (day: any) => (string | JSX.Element),
// i18n
displayFormat?: (string | (()=> string)),
monthFormat?: string,
phrases?: {
closeDatePicker: string | JSX.Element,
},
}
type SingleDatePicker = React.ClassicComponentClass<SingleDatePickerShape>;
var SingleDatePicker: React.ClassicComponentClass<SingleDatePickerShape>;
interface DateRangePickerInputControllerShape {
startDate?: momentPropTypes.momentObj,
startDateId?: string,
startDatePlaceholderText?: string,
isStartDateFocused?: boolean,
endDate?: momentPropTypes.momentObj,
endDateId?: string,
endDatePlaceholderText?: string,
isEndDateFocused?: boolean,
screenReaderMessage?: string,
showClearDates?: boolean,
showCaret?: boolean,
showDefaultInputIcon?: boolean,
disabled?: boolean,
required?: boolean,
keepOpenOnDateSelect?: boolean,
reopenPickerOnClearDates?: boolean,
withFullScreenPortal?: boolean,
isOutsideRange?: (day: any) => boolean,
displayFormat?: (string | (()=> string)),
onFocusChange?: (arg: FocusedInputShape) => void,
onDatesChange?: (arg: { startDate: any, endDate: any }) => void,
customInputIcon?: string | JSX.Element,
customArrowIcon?: string | JSX.Element,
// i18n
phrases?: {
clearDates: string | JSX.Element,
}
}
type DateRangePickerInputController = React.ClassicComponentClass<DateRangePickerInputControllerShape>;
var DateRangePickerInputController: React.ClassicComponentClass<DateRangePickerInputControllerShape>;
interface DateRangePickerInputShape{
startDateId?: string,
startDatePlaceholderText?: string,
screenReaderMessage?: string,
endDateId?: string,
endDatePlaceholderText?: string,
onStartDateFocus?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onEndDateFocus?: (e: React.EventHandler<React.FocusEvent<HTMLInputElement>>) => void,
onStartDateChange?: (e: React.EventHandler<React.FormEvent<HTMLInputElement>>) => void,
onEndDateChange?: (e: React.EventHandler<React.FormEvent<HTMLInputElement>>) => void,
onStartDateShiftTab?: (e: React.EventHandler<React.KeyboardEvent<HTMLInputElement>>) => void,
onEndDateTab?: (e: React.EventHandler<React.KeyboardEvent<HTMLInputElement>>) => void,
onClearDates?: (e: React.EventHandler<React.MouseEvent<HTMLButtonElement>>) => void,
startDate?: string,
startDateValue?: string,
endDate?: string,
endDateValue?: string,
isStartDateFocused?: boolean,
isEndDateFocused?: boolean,
showClearDates?: boolean,
disabled?: boolean,
required?: boolean,
showCaret?: boolean,
showDefaultInputIcon?: boolean,
customInputIcon?: string | JSX.Element,
customArrowIcon?: string | JSX.Element,
// i18n
phrases?:{
clearDates: string | JSX.Element,
},
}
type DateRangePickerInput = React.ClassicComponentClass<DateRangePickerInputShape>;
var DateRangePickerInput: React.ClassicComponentClass<DateRangePickerInputShape>;
interface SingleDatePickerInputShape{
id: string,
placeholder?: string, // also used as label
displayValue?: string,
inputValue?: string,
screenReaderMessage?: string,
focused?: boolean,
disabled?: boolean,
required?: boolean,
showCaret?: boolean,
showClearDate?: boolean,
onChange?: (e: React.EventHandler<React.FormEvent<HTMLInputElement>>) => void,
onClearDate?: (e: React.EventHandler<React.MouseEvent<HTMLButtonElement>>) => void,
onFocus?: (e: React.EventHandler<React.FocusEvent<HTMLInputElement>>) => void,
onKeyDownShiftTab?: (e: React.EventHandler<React.KeyboardEvent<HTMLInputElement>>) => void,
onKeyDownTab?: (e: React.EventHandler<React.KeyboardEvent<HTMLInputElement>>) => void,
// i18n
phrases?: {
clearDate: string | JSX.Element,
}
}
type SingleDatePickerInput = React.ClassicComponentClass<SingleDatePickerInputShape>;
var SingleDatePickerInput: React.ClassicComponentClass<SingleDatePickerInputShape>;
interface DayPickerShape{
enableOutsideDays?: boolean,
numberOfMonths?: number,
modifiers?: any,
orientation?: ScrollableOrientationShape,
withPortal?: boolean,
hidden?: boolean,
initialVisibleMonth?: () => moment.Moment,
navPrev?: string | JSX.Element,
navNext?: string | JSX.Element,
onDayClick?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseEnter?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseLeave?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onPrevMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onNextMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onOutsideClick?: (e: MouseEvent) => void,
renderDay?: (day: any) => (string | JSX.Element),
// i18n
monthFormat?: string,
}
type DayPicker = React.ClassicComponentClass<DayPickerShape>;
var DayPicker: React.ClassicComponentClass<DayPickerShape>;
interface DayPickerRangeControllerShape{
startDate?: momentPropTypes.momentObj,
endDate?: momentPropTypes.momentObj,
onDatesChange?: (arg: { startDate: any, endDate: any }) => void,
focusedInput?: FocusedInputShape,
onFocusChange?: (arg: FocusedInputShape) => void,
keepOpenOnDateSelect?: boolean,
minimumNights?: number,
isOutsideRange?: (day: any) => boolean,
isDayBlocked?: (day: any) => boolean,
isDayHighlighted?: (day: any) => boolean,
// DayPicker props
enableOutsideDays?: boolean,
numberOfMonths?: number,
orientation?: ScrollableOrientationShape,
withPortal?: boolean,
hidden?: boolean,
initialVisibleMonth?: () => moment.Moment,
navPrev?: string | JSX.Element,
navNext?: string | JSX.Element,
onPrevMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onNextMonthClick?: (e: React.EventHandler<React.MouseEvent<HTMLSpanElement>>) => void,
onOutsideClick?: (e: MouseEvent) => void,
renderDay?: (day: any) => (string | JSX.Element),
// i18n
monthFormat?: string,
}
type DayPickerRangeController = React.ClassicComponentClass<DayPickerRangeControllerShape>;
var DayPickerRangeController: React.ClassicComponentClass<DayPickerRangeControllerShape>;
interface CalendarMonthGridShape{
enableOutsideDays?: boolean,
firstVisibleMonthIndex?: number,
initialMonth?: momentPropTypes.momentObj,
isAnimating?: boolean,
numberOfMonths?: number,
modifiers?: any,
orientation?: ScrollableOrientationShape,
onDayClick?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseEnter?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseLeave?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onMonthTransitionEnd?: ()=> void,
renderDay?: (day: any) => (string | JSX.Element),
transformValue?: string,
// i18n
monthFormat?: string,
}
type CalendarMonthGrid = React.ClassicComponentClass<CalendarMonthGridShape>;
var CalendarMonthGrid: React.ClassicComponentClass<CalendarMonthGridShape>;
interface CalendarMonthShape{
month?: momentPropTypes.momentObj,
isVisible?: boolean,
enableOutsideDays?: boolean,
modifiers?: any,
orientation?: ScrollableOrientationShape,
onDayClick?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseEnter?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseLeave?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
renderDay?: (day: any) => (string | JSX.Element),
// i18n
monthFormat?: string,
}
type CalendarMonth = React.ClassicComponentClass<CalendarMonthShape>;
var CalendarMonth: React.ClassicComponentClass<CalendarMonthShape>;
interface CalendarDayShape{
day?: momentPropTypes.momentObj,
isOutsideDay?: boolean,
modifiers?: any,
onDayClick?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseEnter?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
onDayMouseLeave?: (day: any, e: React.EventHandler<React.MouseEvent<HTMLTableDataCellElement>>) => void,
renderDay?: (day: any) => (string | JSX.Element),
}
type CalendarDay = React.ClassicComponentClass<CalendarDayShape>;
var CalendarDay: React.ClassicComponentClass<CalendarDayShape>;
var isInclusivelyAfterDay: (a: moment.Moment, b: moment.Moment) => boolean;
var isInclusivelyBeforeDay: (a: moment.Moment, b: moment.Moment) => boolean;
var isNextDay: (a: moment.Moment, b: moment.Moment) => boolean;
var isSameDay: (a: moment.Moment, b: moment.Moment) => boolean;
var toISODateString: (date: moment.MomentInput, currentFormat: moment.MomentFormatSpecification) => string | null;
var toLocalizedDateString: (date: moment.MomentInput, currentFormat: moment.MomentFormatSpecification) => string | null;
var toMomentObject: (dateString: moment.MomentInput, customFormat: moment.MomentFormatSpecification) => moment.Moment | null;
}

View File

@@ -0,0 +1,357 @@
import moment from "moment";
import * as React from "react";
import {
CalendarDay,
CalendarMonth,
CalendarMonthGrid,
SingleDatePickerInput,
SingleDatePicker,
DayPicker,
DayPickerRangeController,
DateRangePickerInput,
DateRangePickerInputController,
DateRangePicker,
isInclusivelyAfterDay,
isInclusivelyBeforeDay,
isNextDay,
isSameDay,
toISODateString,
toLocalizedDateString,
toMomentObject} from "react-dates";
class CalendarDayRenderingMinimumTest extends React.Component<{}, {}> {
render() {
return <CalendarDay />
}
}
class CalendarDayRenderingFullTest extends React.Component<{}, {}> {
render() {
return <CalendarDay day={moment()}
isOutsideDay={false}
renderDay={day => day.toString()}
onDayClick={(day,e) => {}}
onDayMouseEnter={(day,e) => {}}
onDayMouseLeave={(day,e) => {}}
/>
}
}
class CalendarMonthMinimumTest extends React.Component<{}, {}> {
render() {
return <CalendarMonth />
}
}
class CalendarMonthFullTest extends React.Component<{}, {}> {
render() {
return <CalendarMonth enableOutsideDays={true}
isVisible={true}
month={moment()}
orientation="horizontal"
monthFormat="MM"
renderDay={day => day.toString()}
onDayClick={(day,e) => {}}
onDayMouseEnter={(day,e) => {}}
onDayMouseLeave={(day,e) => {}}
/>
}
}
class SingleDatePickerInputMinimumTest extends React.Component<{}, {}> {
render() {
return <SingleDatePickerInput id="SingleDatePickerInput" />
}
}
class SingleDatePickerInputFullTest extends React.Component<{}, {}> {
render() {
return <SingleDatePickerInput
id="SingleDatePickerInput"
disabled={false}
displayValue="SingleDatePicker"
focused={false}
inputValue="test"
onChange={e => {}}
onClearDate={e => {}}
onFocus={e => {}}
onKeyDownShiftTab={e => {}}
onKeyDownTab={e => {}}
phrases={{clearDate: "clear"}}
placeholder="test"
required={false}
screenReaderMessage="arial-test"
showCaret={true}
showClearDate={true}
/>
}
}
class SingleDatePickerMinimumTest extends React.Component<{}, {}> {
render() {
return <SingleDatePicker id="SingleDatePickerInput" />
}
}
class SingleDatePickerFullTest extends React.Component<{}, {}> {
render() {
return <SingleDatePicker
id="SingleDatePickerInput"
disabled={false}
displayFormat="dd.mm.yyyy"
anchorDirection="right"
date={moment()}
enableOutsideDays={true}
horizontalMargin={20}
initialVisibleMonth={() => moment()}
placeholder="test"
required={false}
showClearDate={true}
isDayBlocked={(day:any)=> false}
isOutsideRange={(day:any)=> false}
keepOpenOnDateSelect={true}
navNext="next"
navPrev="prev"
withPortal={false}
onDateChange={d => {}}
focused={false}
phrases={{closeDatePicker: <span>Close</span>}}
reopenPickerOnClearDates={true}
screenReaderInputMessage="arial-test"
withFullScreenPortal={true}
onFocusChange={arg => {}}
onNextMonthClick={e => {}}
onPrevMonthClick={e => {}}
numberOfMonths={2}
orientation="horizontal"
monthFormat="MM"
renderDay={day => day.toString()}
/>
}
}
class DayPickerRangeControllerMinimumTest extends React.Component<{}, {}> {
render() {
return <DayPickerRangeController />
}
}
class DayPickerRangeControllerFullTest extends React.Component<{}, {}> {
render() {
return <DayPickerRangeController
startDate={moment()}
endDate={moment()}
focusedInput="startDate"
initialVisibleMonth={() => moment()}
hidden={false}
isDayBlocked={(day:any)=> false}
isDayHighlighted={(day:any)=> false}
isOutsideRange={(day:any)=> false}
keepOpenOnDateSelect={true}
minimumNights={3}
navNext="next"
navPrev="prev"
withPortal={false}
onDatesChange={arg => {}}
onFocusChange={arg => {}}
onNextMonthClick={e => {}}
onPrevMonthClick={e => {}}
onOutsideClick={e => {}}
enableOutsideDays={true}
numberOfMonths={2}
orientation="horizontal"
monthFormat="MM"
renderDay={day => day.toString()}
/>
}
}
class DayPickerTest extends React.Component<{}, {}> {
render() {
return <DayPicker />
}
}
class DayPickerFullTest extends React.Component<{}, {}> {
render() {
return <DayPicker
onDayClick={(day,e)=> {}}
onDayMouseEnter={(day,e)=>{}}
onDayMouseLeave={(day,e)=>{}}
initialVisibleMonth={() => moment()}
hidden={false}
navNext="next"
navPrev="prev"
withPortal={false}
onNextMonthClick={e => {}}
onPrevMonthClick={e => {}}
onOutsideClick={e => {}}
enableOutsideDays={true}
numberOfMonths={2}
orientation="horizontal"
monthFormat="MM"
renderDay={day => day.toString()}
/>
}
}
class DateRangePickerInputMinimumTest extends React.Component<{}, {}> {
render() {
return <DateRangePickerInput startDateId="id1" endDateId="id2" />
}
}
class DateRangePickerInputFullTest extends React.Component<{}, {}> {
render() {
return <DateRangePickerInput
customArrowIcon="<"
customInputIcon=">"
disabled={false}
startDateId="id1"
endDateId="id2"
startDateValue={"1.1.2020"}
endDateValue={"1.1.2020"}
startDatePlaceholderText="placeholder"
endDatePlaceholderText="placeholder"
isEndDateFocused={false}
isStartDateFocused={false}
onClearDates={e => {}}
onEndDateChange={e => {}}
onEndDateFocus={e => {}}
onEndDateTab={e => {}}
onStartDateChange={e => {}}
onStartDateFocus={e => {}}
onStartDateShiftTab={e => {}}
showDefaultInputIcon={true}
required={false}
screenReaderMessage="arial-test"
showCaret={true}
showClearDates={true}
phrases={{clearDates: "clear"}}
/>
}
}
class DateRangePickerInputControllerMinimumTest extends React.Component<{}, {}> {
render() {
return <DateRangePickerInputController startDateId="id1" endDateId="id2" />
}
}
class DateRangePickerInputControllerFullTest extends React.Component<{}, {}> {
render() {
return <DateRangePickerInput
customArrowIcon="<"
customInputIcon=">"
disabled={false}
startDateId="id1"
endDateId="id2"
startDateValue={"1.1.2020"}
endDateValue={"1.1.2020"}
startDatePlaceholderText="placeholder"
endDatePlaceholderText="placeholder"
isEndDateFocused={false}
isStartDateFocused={false}
onClearDates={e => {}}
onEndDateChange={e => {}}
onEndDateFocus={e => {}}
onEndDateTab={e => {}}
onStartDateChange={e => {}}
onStartDateFocus={e => {}}
onStartDateShiftTab={e => {}}
showDefaultInputIcon={true}
required={false}
screenReaderMessage="arial-test"
showCaret={true}
showClearDates={true}
phrases={{clearDates: "clear"}}
startDate="1.1.2020"
endDate="1.1.2020"
/>
}
}
class DateRangePickerMinimumTest extends React.Component<{}, {}> {
render() {
return <DateRangePicker startDateId="id1" endDateId="id2" />
}
}
class DateRangePickerFullTest extends React.Component<{}, {}> {
render() {
return <DateRangePicker
disabled={false}
startDateId="id1"
endDateId="id2"
startDatePlaceholderText="placeholder"
endDatePlaceholderText="placeholder"
showDefaultInputIcon={true}
required={false}
showClearDates={true}
phrases={{clearDates: "clear", closeDatePicker: "close"}}
startDate="1.1.2020"
endDate="1.1.2020"
anchorDirection="left"
focusedInput="startDate"
minimumNights={2}
onDatesChange={arg => {arg.startDate; arg.endDate;}}
displayFormat="dd.mm.yyyy"
enableOutsideDays={true}
horizontalMargin={20}
initialVisibleMonth={() => moment()}
isDayBlocked={(day:any)=> false}
isOutsideRange={(day:any)=> false}
keepOpenOnDateSelect={true}
withPortal={false}
reopenPickerOnClearDates={true}
screenReaderInputMessage="arial-test"
withFullScreenPortal={true}
onFocusChange={arg => {}}
onNextMonthClick={e => {}}
onPrevMonthClick={e => {}}
numberOfMonths={2}
orientation="horizontal"
monthFormat="MM"
renderDay={day => day.toString()}
/>
}
}
const isInclusivelyAfterDayResult: boolean = isInclusivelyAfterDay(moment(),moment());
const isInclusivelyBeforeDayResult: boolean = isInclusivelyBeforeDay(moment(),moment());
const isNextDayDayResult: boolean = isNextDay(moment(),moment());
const isSameDayResult: boolean = isSameDay(moment(),moment());
const toISODateStringResult: string | null = toISODateString(moment(), "dd.mm.yyyy");
const toLocalizedDateStringResult: string | null = toLocalizedDateString(moment(), "dd.mm.yyyy");
const toMomentObjectResult: moment.Moment | null = toMomentObject(moment(), "dd.mm.yyyy");

24
react-dates/tsconfig.json Normal file
View File

@@ -0,0 +1,24 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"jsx": "react",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"react-day-picker-tests.tsx"
]
}