You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
433 lines
13 KiB
433 lines
13 KiB
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
/**
|
|
* A UI node that can be rendered by React. React can render most primitives in
|
|
* addition to elements and arrays of nodes.
|
|
*/
|
|
|
|
declare type React$Node =
|
|
| null
|
|
| boolean
|
|
| number
|
|
| string
|
|
| React$Element<any>
|
|
| React$Portal
|
|
| Iterable<?React$Node>;
|
|
|
|
/**
|
|
* Base class of ES6 React classes, modeled as a polymorphic class whose main
|
|
* type parameters are Props and State.
|
|
*/
|
|
declare class React$Component<Props, State = void> {
|
|
// fields
|
|
|
|
props: Props;
|
|
state: State;
|
|
|
|
// action methods
|
|
|
|
setState(
|
|
partialState: ?$Shape<State> | ((State, Props) => ?$Shape<State>),
|
|
callback?: () => mixed,
|
|
): void;
|
|
|
|
forceUpdate(callback?: () => void): void;
|
|
|
|
// lifecycle methods
|
|
|
|
constructor(props?: Props, context?: any): void;
|
|
render(): React$Node;
|
|
componentWillMount(): mixed;
|
|
UNSAFE_componentWillMount(): mixed;
|
|
componentDidMount(): mixed;
|
|
componentWillReceiveProps(
|
|
nextProps: Props,
|
|
nextContext: any,
|
|
): mixed;
|
|
UNSAFE_componentWillReceiveProps(
|
|
nextProps: Props,
|
|
nextContext: any,
|
|
): mixed;
|
|
shouldComponentUpdate(
|
|
nextProps: Props,
|
|
nextState: State,
|
|
nextContext: any,
|
|
): boolean;
|
|
componentWillUpdate(
|
|
nextProps: Props,
|
|
nextState: State,
|
|
nextContext: any,
|
|
): mixed;
|
|
UNSAFE_componentWillUpdate(
|
|
nextProps: Props,
|
|
nextState: State,
|
|
nextContext: any,
|
|
): mixed;
|
|
componentDidUpdate(
|
|
prevProps: Props,
|
|
prevState: State,
|
|
prevContext: any,
|
|
): mixed;
|
|
componentWillUnmount(): mixed;
|
|
componentDidCatch(
|
|
error: Error,
|
|
info: {
|
|
componentStack: string,
|
|
}
|
|
): mixed;
|
|
|
|
// long tail of other stuff not modeled very well
|
|
|
|
refs: any;
|
|
context: any;
|
|
getChildContext(): any;
|
|
static displayName?: ?string;
|
|
static childContextTypes: any;
|
|
static contextTypes: any;
|
|
static propTypes: any;
|
|
|
|
// We don't add a type for `defaultProps` so that its type may be entirely
|
|
// inferred when we diff the type for `defaultProps` with `Props`. Otherwise
|
|
// the user would need to define a type (which would be redundant) to override
|
|
// the type we provide here in the base class.
|
|
//
|
|
// static defaultProps: $Shape<Props>;
|
|
}
|
|
|
|
declare class React$PureComponent<Props, State = void>
|
|
extends React$Component<Props, State> {
|
|
// TODO: Due to bugs in Flow's handling of React.createClass, some fields
|
|
// already declared in the base class need to be redeclared below. Ideally
|
|
// they should simply be inherited.
|
|
|
|
props: Props;
|
|
state: State;
|
|
}
|
|
|
|
/**
|
|
* Base class of legacy React classes, which extends the base class of ES6 React
|
|
* classes and supports additional methods.
|
|
*/
|
|
declare class LegacyReactComponent<Props, State>
|
|
extends React$Component<Props, State> {
|
|
// additional methods
|
|
|
|
replaceState(state: State, callback?: () => void): void;
|
|
|
|
isMounted(): bool;
|
|
|
|
// TODO: Due to bugs in Flow's handling of React.createClass, some fields
|
|
// already declared in the base class need to be redeclared below. Ideally
|
|
// they should simply be inherited.
|
|
|
|
props: Props;
|
|
state: State;
|
|
}
|
|
|
|
declare type React$AbstractComponentStatics = {
|
|
displayName?: ?string,
|
|
// This is only on function components, but trying to access name when
|
|
// displayName is undefined is a common pattern.
|
|
name?: ?string,
|
|
};
|
|
|
|
/**
|
|
* The type of a stateless functional component. In most cases these components
|
|
* are a single function. However, they may have some static properties that we
|
|
* can type check.
|
|
*/
|
|
declare type React$StatelessFunctionalComponent<Props> = {
|
|
(props: Props, context: any): React$Node,
|
|
displayName?: ?string,
|
|
propTypes?: any,
|
|
contextTypes?: any
|
|
};
|
|
|
|
/**
|
|
* The type of a component in React. A React component may be a:
|
|
*
|
|
* - Stateless functional components. Functions that take in props as an
|
|
* argument and return a React node.
|
|
* - ES6 class component. Components with state defined either using the ES6
|
|
* class syntax, or with the legacy `React.createClass()` helper.
|
|
*/
|
|
declare type React$ComponentType<-Config> = React$AbstractComponent<Config, any>;
|
|
|
|
/**
|
|
* The type of an element in React. A React element may be a:
|
|
*
|
|
* - String. These elements are intrinsics that depend on the React renderer
|
|
* implementation.
|
|
* - React component. See `ComponentType` for more information about its
|
|
* different variants.
|
|
*/
|
|
declare type React$ElementType =
|
|
| string
|
|
| React$AbstractComponent<any, any>;
|
|
|
|
/**
|
|
* Type of a React element. React elements are commonly created using JSX
|
|
* literals, which desugar to React.createElement calls (see below).
|
|
*/
|
|
declare type React$Element<+ElementType: React$ElementType> = {|
|
|
+type: ElementType,
|
|
+props: React$ElementProps<ElementType>,
|
|
+key: React$Key | null,
|
|
+ref: any,
|
|
|};
|
|
|
|
/**
|
|
* The type of the key that React uses to determine where items in a new list
|
|
* have moved.
|
|
*/
|
|
declare type React$Key = string | number;
|
|
|
|
/**
|
|
* The type of the ref prop available on all React components.
|
|
*/
|
|
declare type React$Ref<ElementType: React$ElementType> =
|
|
| {current: React$ElementRef<ElementType> | null}
|
|
| ((React$ElementRef<ElementType> | null) => mixed)
|
|
| string;
|
|
|
|
/**
|
|
* The type of a React Context. React Contexts are created by calling
|
|
* createContext() with a default value.
|
|
*/
|
|
declare type React$Context<T> = {
|
|
Provider: React$ComponentType<{ value: T, children?: ?React$Node }>,
|
|
Consumer: React$ComponentType<{ children: (value: T) => ?React$Node }>,
|
|
}
|
|
|
|
/**
|
|
* A React portal node. The implementation of the portal node is hidden to React
|
|
* users so we use an opaque type.
|
|
*/
|
|
declare opaque type React$Portal;
|
|
|
|
declare module react {
|
|
declare export var DOM: any;
|
|
declare export var PropTypes: ReactPropTypes;
|
|
declare export var version: string;
|
|
|
|
declare export function checkPropTypes<V>(
|
|
propTypes : any,
|
|
values: V,
|
|
location: string,
|
|
componentName: string,
|
|
getStack: ?(() => ?string)
|
|
) : void;
|
|
|
|
declare export var createClass: React$CreateClass;
|
|
declare export function createContext<T>(
|
|
defaultValue: T,
|
|
calculateChangedBits: ?(a: T, b: T) => number,
|
|
): React$Context<T>;
|
|
declare export var createElement: React$CreateElement;
|
|
declare export var cloneElement: React$CloneElement;
|
|
declare export function createFactory<ElementType: React$ElementType>(
|
|
type: ElementType,
|
|
): React$ElementFactory<ElementType>;
|
|
declare export function createRef<T>(
|
|
): {current: null | T};
|
|
|
|
declare export function isValidElement(element: any): boolean;
|
|
|
|
declare export var Component: typeof React$Component;
|
|
declare export var PureComponent: typeof React$PureComponent;
|
|
declare export type StatelessFunctionalComponent<P> =
|
|
React$StatelessFunctionalComponent<P>;
|
|
declare export type ComponentType<-P> = React$ComponentType<P>;
|
|
declare export type AbstractComponent<
|
|
-Config,
|
|
+Instance = mixed,
|
|
> = React$AbstractComponent<Config, Instance>;
|
|
declare export type ElementType = React$ElementType;
|
|
declare export type Element<+C> = React$Element<C>;
|
|
declare export var Fragment: ({children: ?React$Node}) => React$Node;
|
|
declare export type Key = React$Key;
|
|
declare export type Ref<C> = React$Ref<C>;
|
|
declare export type Node = React$Node;
|
|
declare export type Context<T> = React$Context<T>;
|
|
declare export type Portal = React$Portal;
|
|
declare export var ConcurrentMode: ({children: ?React$Node}) => React$Node; // 16.7+
|
|
declare export var StrictMode: ({children: ?React$Node}) => React$Node;
|
|
|
|
declare export var Suspense: React$ComponentType<{
|
|
children?: ?React$Node,
|
|
fallback?: React$Node,
|
|
maxDuration?: number
|
|
}>; // 16.6+
|
|
|
|
declare export type ElementProps<C> = React$ElementProps<C>;
|
|
declare export type ElementConfig<C> = React$ElementConfig<C>;
|
|
declare export type ElementRef<C> = React$ElementRef<C>;
|
|
declare export type Config<Props, DefaultProps> = React$Config<Props, DefaultProps>;
|
|
|
|
declare export type ChildrenArray<+T> = $ReadOnlyArray<ChildrenArray<T>> | T;
|
|
declare export var Children: {
|
|
map<T, U>(
|
|
children: ChildrenArray<T>,
|
|
fn: (child: $NonMaybeType<T>, index: number) => U,
|
|
thisArg?: mixed,
|
|
): Array<$NonMaybeType<U>>;
|
|
forEach<T>(
|
|
children: ChildrenArray<T>,
|
|
fn: (child: T, index: number) => mixed,
|
|
thisArg?: mixed,
|
|
): void;
|
|
count(children: ChildrenArray<any>): number;
|
|
only<T>(children: ChildrenArray<T>): $NonMaybeType<T>;
|
|
toArray<T>(children: ChildrenArray<T>): Array<$NonMaybeType<T>>;
|
|
};
|
|
|
|
declare export function forwardRef<Config, Instance>(
|
|
render: (
|
|
props: Config,
|
|
ref: {current: null | Instance} | ((null | Instance) => mixed),
|
|
) => React$Node,
|
|
): React$AbstractComponent<Config, Instance>;
|
|
|
|
declare export function memo<P>(
|
|
component: React$StatelessFunctionalComponent<P>,
|
|
equal?: (P, P) => boolean,
|
|
): React$StatelessFunctionalComponent<P>;
|
|
|
|
declare export function lazy<P>(
|
|
component: () => Promise<{ default: React$ComponentType<P> }>,
|
|
): React$ComponentType<P>;
|
|
|
|
declare type MaybeCleanUpFn = ?(() => mixed);
|
|
|
|
declare export function useContext<T>(
|
|
context: React$Context<T>,
|
|
observedBits: void | number | boolean,
|
|
): T;
|
|
|
|
declare export function useState<S>(
|
|
initialState: (() => S) | S,
|
|
): [S, ((S => S) | S) => void];
|
|
|
|
declare export function useReducer<S, A>(
|
|
reducer: (S, A) => S,
|
|
initialState: S,
|
|
initialAction: ?A,
|
|
): [S, A => void];
|
|
|
|
declare export function useRef<T>(initialValue: ?T): {current: T | null};
|
|
|
|
declare export function useEffect(
|
|
create: () => MaybeCleanUpFn,
|
|
inputs: ?$ReadOnlyArray<mixed>,
|
|
): void;
|
|
|
|
declare export function useLayoutEffect(
|
|
create: () => MaybeCleanUpFn,
|
|
inputs: ?$ReadOnlyArray<mixed>,
|
|
): void;
|
|
|
|
declare export function useCallback<T: (...args: $ReadOnlyArray<empty>) => mixed>(
|
|
callback: T,
|
|
inputs: ?$ReadOnlyArray<mixed>,
|
|
): T;
|
|
|
|
declare export function useMemo<T>(
|
|
create: () => T,
|
|
inputs: ?$ReadOnlyArray<mixed>,
|
|
): T;
|
|
|
|
declare export function useImperativeMethods<T>(
|
|
ref: {current: T | null} | ((inst: T | null) => mixed) | null | void,
|
|
create: () => T,
|
|
inputs: ?$ReadOnlyArray<mixed>,
|
|
): void;
|
|
|
|
declare export default {|
|
|
+DOM: typeof DOM,
|
|
+PropTypes: typeof PropTypes,
|
|
+version: typeof version,
|
|
+checkPropTypes: typeof checkPropTypes,
|
|
+memo: typeof memo,
|
|
+lazy: typeof lazy,
|
|
+createClass: typeof createClass,
|
|
+createContext: typeof createContext,
|
|
+createElement: typeof createElement,
|
|
+cloneElement: typeof cloneElement,
|
|
+createFactory: typeof createFactory,
|
|
+createRef: typeof createRef,
|
|
+forwardRef: typeof forwardRef,
|
|
+isValidElement: typeof isValidElement,
|
|
+Component: typeof Component,
|
|
+PureComponent: typeof PureComponent,
|
|
+Fragment: typeof Fragment,
|
|
+Children: typeof Children,
|
|
+ConcurrentMode: typeof ConcurrentMode,
|
|
+StrictMode: typeof StrictMode,
|
|
+Suspense: typeof Suspense,
|
|
+useContext: typeof useContext,
|
|
+useState: typeof useState,
|
|
+useReducer: typeof useReducer,
|
|
+useRef: typeof useRef,
|
|
+useEffect: typeof useEffect,
|
|
+useLayoutEffect: typeof useLayoutEffect,
|
|
+useCallback: typeof useCallback,
|
|
+useMemo: typeof useMemo,
|
|
+useImperativeMethods: typeof useImperativeMethods,
|
|
|};
|
|
}
|
|
|
|
// TODO Delete this once https://github.com/facebook/react/pull/3031 lands
|
|
// and "react" becomes the standard name for this module
|
|
declare module React {
|
|
declare module.exports: $Exports<'react'>;
|
|
}
|
|
|
|
type ReactPropsCheckType = (
|
|
props: any,
|
|
propName: string,
|
|
componentName: string,
|
|
href?: string) => ?Error;
|
|
|
|
type ReactPropsChainableTypeChecker = {
|
|
isRequired: ReactPropsCheckType;
|
|
(props: any, propName: string, componentName: string, href?: string): ?Error;
|
|
};
|
|
|
|
type React$PropTypes$arrayOf =
|
|
(typeChecker: ReactPropsCheckType) => ReactPropsChainableTypeChecker;
|
|
type React$PropTypes$instanceOf =
|
|
(expectedClass: any) => ReactPropsChainableTypeChecker;
|
|
type React$PropTypes$objectOf =
|
|
(typeChecker: ReactPropsCheckType) => ReactPropsChainableTypeChecker;
|
|
type React$PropTypes$oneOf =
|
|
(expectedValues: Array<any>) => ReactPropsChainableTypeChecker;
|
|
type React$PropTypes$oneOfType =
|
|
(arrayOfTypeCheckers: Array<ReactPropsCheckType>) =>
|
|
ReactPropsChainableTypeChecker;
|
|
type React$PropTypes$shape =
|
|
(shapeTypes: { [key: string]: ReactPropsCheckType }) =>
|
|
ReactPropsChainableTypeChecker;
|
|
|
|
type ReactPropTypes = {
|
|
array: React$PropType$Primitive<Array<any>>;
|
|
bool: React$PropType$Primitive<boolean>;
|
|
func: React$PropType$Primitive<Function>;
|
|
number: React$PropType$Primitive<number>;
|
|
object: React$PropType$Primitive<Object>;
|
|
string: React$PropType$Primitive<string>;
|
|
any: React$PropType$Primitive<any>;
|
|
arrayOf: React$PropType$ArrayOf;
|
|
element: React$PropType$Primitive<any>; /* TODO */
|
|
instanceOf: React$PropType$InstanceOf;
|
|
node: React$PropType$Primitive<any>; /* TODO */
|
|
objectOf: React$PropType$ObjectOf;
|
|
oneOf: React$PropType$OneOf;
|
|
oneOfType: React$PropType$OneOfType;
|
|
shape: React$PropType$Shape;
|
|
}
|