;
- update(object: Object, changes: Object): Object;
- };
-
- export interface CloneWithProps {
- (instance: ReactComponentElement
, extraProps?: P): ReactComponentElement
;
- }
-
- export interface ReactLink {
- value: T;
- requestChange(newValue: T): void;
- }
-
- export interface LinkedStateMixin extends Mixin {
- linkState(key: string): ReactLink;
- }
-
- export interface ComponentPerfContext {
- current: string;
- owner: string;
- }
-
- export interface CSSTransitionGroupProps {
- transitionName: string;
- }
-
- export interface TransitionsSpecification extends Specification {
- componentWillEnter?(callback: () => void): void;
- componentDidEnter?(): void;
- componentWillLeave?(callback: () => void): void;
- componentDidLeave?(): void;
- }
-
- export interface NumericPerfContext {
- [key: string]: number;
- }
-
- export interface Measurements {
- exclusive: NumericPerfContext;
- inclusive: NumericPerfContext;
- render: NumericPerfContext;
- counts: NumericPerfContext;
- writes: NumericPerfContext;
- displayNames: {
- [key: string]: ComponentPerfContext;
- };
- totalTime: number;
- }
-
- export interface Perf {
- start(): void;
- stop(): void;
- printInclusive(measurements: Measurements[]): void;
- printExclusive(measurements: Measurements[]): void;
- printWasted(measurements: Measurements[]): void;
- printDOM(measurements: Measurements[]): void;
- getLastMeasurements(): Measurements[];
- }
-
- export interface TestUtils {
- Simulate: Simulate;
- renderIntoDocument(instance: ReactComponentElement
): ReactComponentElement
;
- renderIntoDocument(instance: ReactHTMLElement): ReactHTMLElement;
- renderIntoDocument(instance: ReactSVGElement): ReactSVGElement;
- mockComponent(componentClass: ReactComponentFactory, mockTagName?: string): TestUtils;
- isDescriptorOfType(descriptor: ReactElement, componentClass: ReactComponentFactory): boolean;
- isDOMComponent(instance: ReactElement): boolean;
- isCompositeComponent(instance: ReactElement): boolean;
- isCompositeComponentWithType(instance: ReactElement, componentClass: ReactComponentFactory): boolean;
- isTextComponent(instance: ReactElement): boolean;
- findAllInRenderedTree(tree: ReactElement, test: (component: ReactElement) => boolean): ReactElement[];
- scryRenderedDOMComponentsWithClass(tree: ReactElement, className: string): ReactElement[];
- findRenderedDOMComponentWithClass(tree: ReactElement, className: string): ReactElement;
- scryRenderedDOMComponentsWithTag(tree: ReactElement, tagName: string): ReactElement[];
- findRenderedDOMComponentWithTag(tree: ReactElement, tagName: string): ReactElement;
- scryRenderedComponentsWithTag(tree: ReactElement, componentClass: Function): ReactElement[];
- findRenderedComponentWithType(tree: ReactElement, componentClass: ReactComponentFactory): Component;
- scryRenderedComponentsWithType(tree: ReactElement, componentClass: ReactComponentFactory): Component[];
- }
-
- export interface SyntheticEventData {
- altKey?: boolean;
- button?: number;
- buttons?: number;
- clientX?: number;
- clientY?: number;
- changedTouches?: TouchList;
- charCode?: boolean;
- clipboardData?: DataTransfer;
- ctrlKey?: boolean;
- deltaMode?: number;
- deltaX?: number;
- deltaY?: number;
- deltaZ?: number;
- detail?: number;
- getModifierState?(key: string): boolean;
- key?: string;
- keyCode?: number;
- locale?: string;
- location?: number;
- metaKey?: boolean;
- pageX?: number;
- pageY?: number;
- relatedTarget?: EventTarget;
- repeat?: boolean;
- screenX?: number;
- screenY?: number;
- shiftKey?: boolean;
- targetTouches?: TouchList;
- touches?: TouchList;
- view?: AbstractView;
- which?: number;
- }
-
- export interface EventSimulator {
- (element: Element, eventData?: SyntheticEventData): void;
- (descriptor: ReactElement, eventData?: SyntheticEventData): void;
- }
-
- export interface Simulate {
- blur: EventSimulator;
- change: EventSimulator;
- click: EventSimulator;
- cut: EventSimulator;
- doubleClick: EventSimulator;
- drag: EventSimulator;
- dragEnd: EventSimulator;
- dragEnter: EventSimulator;
- dragExit: EventSimulator;
- dragLeave: EventSimulator;
- dragOver: EventSimulator;
- dragStart: EventSimulator;
- drop: EventSimulator;
- focus: EventSimulator;
- input: EventSimulator;
- keyDown: EventSimulator;
- keyPress: EventSimulator;
- keyUp: EventSimulator;
- mouseDown: EventSimulator;
- mouseEnter: EventSimulator;
- mouseLeave: EventSimulator;
- mouseMove: EventSimulator;
- mouseOut: EventSimulator;
- mouseOver: EventSimulator;
- mouseUp: EventSimulator;
- paste: EventSimulator;
- scroll: EventSimulator;
- submit: EventSimulator;
- touchCancel: EventSimulator;
- touchEnd: EventSimulator;
- touchMove: EventSimulator;
- touchStart: EventSimulator;
- wheel: EventSimulator;
- }
-}
diff --git a/react-addons/legacy/react-addons-0.11-tests.ts b/react/legacy/react-addons-0.11-tests.ts
similarity index 100%
rename from react-addons/legacy/react-addons-0.11-tests.ts
rename to react/legacy/react-addons-0.11-tests.ts
diff --git a/react-addons/legacy/react-addons-0.11.d.ts b/react/legacy/react-addons-0.11.d.ts
similarity index 98%
rename from react-addons/legacy/react-addons-0.11.d.ts
rename to react/legacy/react-addons-0.11.d.ts
index 3e2f22a513..d027402468 100644
--- a/react-addons/legacy/react-addons-0.11.d.ts
+++ b/react/legacy/react-addons-0.11.d.ts
@@ -3,7 +3,7 @@
// Definitions by: Asana
// Definitions: https://github.com/borisyankov/DefinitelyTyped
-///
+///
declare module "react/addons-0.11" {
export = React;
diff --git a/react/react-addons-tests.ts b/react/react-addons-tests.ts
new file mode 100644
index 0000000000..059769bb94
--- /dev/null
+++ b/react/react-addons-tests.ts
@@ -0,0 +1,42 @@
+///
+import React = require("react/addons");
+
+// TestUtils
+var that: React.CompositeComponent;
+var node = that.refs["input"].getDOMNode();
+React.addons.TestUtils.Simulate.click(node);
+React.addons.TestUtils.Simulate.change(node);
+React.addons.TestUtils.Simulate.keyDown(node, {key: "Enter"});
+
+interface GreetingProps {
+ name: string;
+}
+interface GreetingState {
+ morning: boolean;
+}
+interface Greeting extends React.CompositeComponent {
+}
+var Greeting = React.createClass({displayName: "Greeting",
+ getInitialState: function() {
+ return {morning: true};
+ },
+ render: function() {
+ var me = this;
+ return React.DOM.div(null, (me.state.morning ? "Hello" : "Goodbye "), me.props.name);
+ }
+});
+
+var root = React.addons.TestUtils.renderIntoDocument(React.createElement(Greeting, {name: "John"}));
+var greeting = React.addons.TestUtils.findRenderedComponentWithType(root, Greeting);
+greeting.setState({
+ morning: false
+});
+
+var isImportant: boolean;
+var isRead: boolean;
+var cx = React.addons.classSet;
+var classes: string = cx({
+ "message": true,
+ "message-important": isImportant,
+ "message-read": isRead
+});
diff --git a/react/react-tests.ts b/react/react-tests.ts
index 37380b23b9..6571556189 100644
--- a/react/react-tests.ts
+++ b/react/react-tests.ts
@@ -1,64 +1,152 @@
///
import React = require("react");
-var PropTypesSpecification: React.Specification = {
+interface Props {
+ hello: string;
+ world?: string;
+ foo: number;
+ bar: boolean;
+}
+
+interface State {
+ inputValue?: string;
+ seconds?: number;
+}
+
+interface MyComponent extends React.CompositeComponent {
+ reset(): void;
+}
+
+var props: Props = {
+ hello: "world",
+ foo: 42,
+ bar: true
+};
+
+var container: Element;
+var INPUT_REF: string = "input";
+
+//
+// Top-Level API
+// --------------------------------------------------------------------------
+
+var reactClass: React.ComponentClass = React.createClass({
+ getDefaultProps: () => {
+ return {
+ hello: undefined,
+ world: "peace",
+ foo: undefined,
+ bar: undefined
+ };
+ },
+ getInitialState: () => {
+ return {
+ inputValue: "React.js",
+ seconds: 0
+ };
+ },
+ reset: () => {
+ this.replaceState(this.getInitialState());
+ },
+ render: () => {
+ return React.DOM.div(null,
+ React.DOM.input({
+ ref: INPUT_REF,
+ value: this.state.inputValue
+ }));
+ }
+});
+
+var reactElement: React.ReactElement =
+ React.createElement(reactClass, props);
+
+var reactFactory: React.Factory =
+ React.createFactory(reactClass);
+
+var component: React.Component =
+ React.render(reactElement, container);
+
+var unmounted: boolean = React.unmountComponentAtNode(container);
+var str: string = React.renderToString(reactElement);
+var markup: string = React.renderToStaticMarkup(reactElement);
+var notValid: boolean = React.isValidElement(props); // false
+var isValid = React.isValidElement(reactElement); // true
+React.initializeTouchEvents(true);
+
+//
+// React Elements
+// --------------------------------------------------------------------------
+
+var type = reactElement.type;
+var elementProps: Props = reactElement.props;
+var key = reactElement.key;
+var ref: string = reactElement.ref;
+var factoryElement: React.ReactElement = reactFactory(elementProps);
+
+//
+// React Components
+// --------------------------------------------------------------------------
+
+var displayName: string = reactClass.displayName;
+var defaultProps: Props = reactClass.getDefaultProps();
+var propTypes: React.ValidationMap = reactClass.propTypes;
+
+//
+// Component API
+// --------------------------------------------------------------------------
+
+var htmlElement: Element = component.getDOMNode();
+var divElement: HTMLDivElement = component.getDOMNode();
+var isMounted: boolean = component.isMounted();
+component.setProps(elementProps);
+component.replaceProps(props);
+
+var compComponent: React.CompositeComponent =
+ >component;
+var initialState: State = compComponent.state;
+compComponent.setState({ inputValue: "!!!" });
+compComponent.replaceState({ inputValue: "???", seconds: 60 });
+compComponent.forceUpdate();
+
+var inputRef: React.HTMLComponent =
+ compComponent.refs[INPUT_REF];
+var value: string = inputRef.getDOMNode().value;
+
+var myComponent = compComponent;
+myComponent.reset();
+
+//
+// PropTypes
+// --------------------------------------------------------------------------
+
+var PropTypesSpecification: React.ComponentSpec = {
propTypes: {
- // You can declare that a prop is a specific JS primitive. By default, these
- // are all optional.
optionalArray: React.PropTypes.array,
optionalBool: React.PropTypes.bool,
optionalFunc: React.PropTypes.func,
optionalNumber: React.PropTypes.number,
optionalObject: React.PropTypes.object,
optionalString: React.PropTypes.string,
-
- // Anything that can be rendered: numbers, strings, components or an array
- // containing these types.
- optionalRenderable: React.PropTypes.node,
-
- // A React component.
- optionalComponent: React.PropTypes.component,
-
- // You can also declare that a prop is an instance of a class. This uses
- // JS's instanceof operator.
+ optionalNode: React.PropTypes.node,
+ optionalElement: React.PropTypes.element,
optionalMessage: React.PropTypes.instanceOf(Date),
-
- // You can ensure that your prop is limited to specific values by treating
- // it as an enum.
- optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
-
- // An object that could be one of many types
+ optionalEnum: React.PropTypes.oneOf(["News", "Photos"]),
optionalUnion: React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.number,
React.PropTypes.instanceOf(Date)
]),
-
- // An array of a certain type
optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-
- // An object with property values of a certain type
optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-
- // An object taking on a particular shape
optionalObjectWithShape: React.PropTypes.shape({
color: React.PropTypes.string,
fontSize: React.PropTypes.number
}),
-
- // You can chain any of the above with `isRequired` to make sure a warning
- // is shown if the prop isn't provided.
requiredFunc: React.PropTypes.func.isRequired,
-
- // A value of any data type
requiredAny: React.PropTypes.any.isRequired,
-
- // You can also specify a custom validator. It should return an Error
- // object if the validation fails. Don't `console.warn` or throw, as this
- // won't work inside `oneOfType`.
- customProp: function(props, propName, componentName) {
+ customProp: function(props: any, propName: string, componentName: string) {
if (!/matchme/.test(props[propName])) {
- return new Error('Validation failed!');
+ return new Error("Validation failed!");
}
return null;
}
@@ -68,50 +156,41 @@ var PropTypesSpecification: React.Specification = {
}
};
-React.createClass(PropTypesSpecification);
+//
+// Example from http://facebook.github.io/react/
+// --------------------------------------------------------------------------
-var mountNode: Element;
-
-interface HelloMessageProps {
- name: string;
+interface TimerState {
+ secondsElapsed: number;
}
-
-var HelloMessage = React.createClass({displayName: 'HelloMessage',
- render: function() {
- return React.DOM.div(null, "Hello ", (>this).props.name);
- }
-});
-
-// This code - calling a component directly - is deprecated in v0.12
-// See http://fb.me/react-legacyfactory
-React.render(HelloMessage({ name: "John" }), mountNode);
-
-// Create a factory instead
-var HelloMessageFactory = React.createFactory(HelloMessage)
-React.render(HelloMessageFactory({ name: "John" }), mountNode)
-
-var Timer = React.createClass({displayName: 'Timer',
- getInitialState: function() {
- return {secondsElapsed: 0};
+interface Timer extends React.CompositeComponent<{}, TimerState> {
+}
+var Timer = React.createClass({
+ displayName: "Timer",
+ getInitialState: () => {
+ return { secondsElapsed: 0 };
},
- tick: function() {
- (>this).setState({
- secondsElapsed: (>this).state.secondsElapsed + 1
+ tick: () => {
+ var me = this;
+ me.setState({
+ secondsElapsed: me.state.secondsElapsed + 1
});
},
- componentDidMount: function() {
+ componentDidMount: () => {
this.interval = setInterval(this.tick, 1000);
},
- componentWillUnmount: function() {
+ componentWillUnmount: () => {
clearInterval(this.interval);
},
- render: function() {
+ render: () => {
+ var me = this;
return React.DOM.div(
null,
"Seconds Elapsed: ",
- (>this).state.secondsElapsed
+ me.state.secondsElapsed
);
}
});
+var mountNode: Element;
+React.render(React.createElement(Timer, null), mountNode);
-React.render(Timer(), mountNode);
\ No newline at end of file
diff --git a/react/react.d.ts b/react/react.d.ts
index 03d11a8a9a..1356b1280f 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -1,99 +1,125 @@
-// Type definitions for React 0.12.RC
+// Type definitions for React 0.12.1
// Project: http://facebook.github.io/react/
// Definitions by: Asana
// Definitions: https://github.com/borisyankov/DefinitelyTyped
-declare module "react" {
- export = React;
-}
-
declare module React {
- export function createClass(specification: Specification): ReactComponentFactory;
+ //
+ // React Elements
+ // ----------------------------------------------------------------------
- export function createFactory
(clazz: ReactComponentFactory
): ReactComponentFactory
;
+ // type ReactType = ComponentClass | string;
- export function createElement(clazz: ReactComponentFactory
, props: P, ...children: any[]): ReactComponentElement
;
-
- export function createElement(type: string, props: DomAttributes, ...children: any[]): ReactHTMLElement;
-
- export function createElement(type: string, props: SvgAttributes, ...children: any[]): ReactSVGElement;
-
- export function render
(component: ReactComponentElement
, container: Element, callback?: () => void): Component;
-
- export function render(component: ReactHTMLElement, container: Element, callback?: () => void): ReactHTMLElement;
-
- export function render(component: ReactSVGElement, container: Element, callback?: () => void): ReactSVGElement;
-
- export function unmountComponentAtNode(container: Element): boolean;
-
- export function renderToString(component: ReactComponentElement
): string;
-
- export function renderToString(component: ReactHTMLElement): string;
-
- export function renderToString(component: ReactSVGElement): string;
-
- export function renderToStaticMarkup
(component: ReactComponentElement
): string;
-
- export function renderToStaticMarkup(component: ReactHTMLElement): string;
-
- export function renderToStaticMarkup(component: ReactSVGElement): string;
-
- export function isValidClass(factory: ReactComponentFactory): boolean;
-
- export function isValidElement(component: ReactComponentElement): boolean;
-
- export function isValidElement(component: ReactHTMLElement): boolean;
-
- export function isValidElement(component: ReactSVGElement): boolean;
-
- export function initializeTouchEvents(shouldUseTouch: boolean): void;
-
-
- export interface ReactComponentFactory {
- (properties?: P, ...children: any[]): ReactComponentElement
;
- }
-
- export interface ReactElementFactory
{
- (properties?: P, ...children: any[]): ReactDOMElement
;
- }
-
- export interface DomElement extends ReactElementFactory {
- }
-
- export interface SvgElement extends ReactElementFactory {
- }
-
- export interface ReactClass {
- (props: P): ReactComponent
;
- }
-
- export interface ReactComponent
{
+ interface ReactElement
{
+ type: any; // ReactType
props: P;
- render(): ReactElement;
- }
-
- export interface ReactElement {
- type: T;
- props: P;
- key: string;
+ key: any; // number | string
ref: string;
}
- export interface ReactDOMElement extends ReactElement {
+ interface ReactHTMLElement extends ReactElement {}
+ interface ReactSVGElement extends ReactElement {}
+ interface ComponentElement extends ReactElement
{}
+
+ //
+ // React Nodes
+ // ----------------------------------------------------------------------
+
+ // type ReactText = string | number;
+ // type Fragment = ReactNode[];
+ // type ReactNode = ReactElement | Fragment | ReactText;
+
+ //
+ // React Components
+ // ----------------------------------------------------------------------
+
+ interface ComponentStatics {
+ displayName?: string;
+ getDefaultProps?(): P;
+ propTypes?: ValidationMap
;
+ }
+
+ interface ComponentClass
extends ComponentStatics
{
+ // Deprecated in 0.12. See http://fb.me/react-legacyfactory
+ // new(props: P): ReactElement
;
+ // (props: P): ReactElement
;
+ }
+
+ //
+ // ReactElement Factories
+ // ----------------------------------------------------------------------
+
+ interface Factory
{
+ (props?: P, ...children: any/*ReactNode*/[]): ReactElement
;
+ }
+
+ interface HTMLFactory extends Factory {}
+ interface SVGFactory extends Factory {}
+ interface ComponentFactory extends Factory
{}
+
+ //
+ // Top-Level API
+ // ----------------------------------------------------------------------
+
+ interface TopLevelAPI {
+ createClass
(spec: ComponentSpec): ComponentClass;
+ createElement
(type: any/*ReactType*/, props: P, ...children: any/*ReactNode*/[]): ReactElement
;
+ createFactory
(componentClass: ComponentClass
): Factory
;
+ render
(element: ReactElement
, container: Element, callback?: () => void): Component
;
+ unmountComponentAtNode(container: Element): boolean;
+ renderToString(element: ReactElement): string;
+ renderToStaticMarkup(element: ReactElement): string;
+ isValidElement(object: {}): boolean;
+ initializeTouchEvents(shouldUseTouch: boolean): void;
+ }
+
+ //
+ // Component API
+ // ----------------------------------------------------------------------
+
+ interface Component {
+ // Use this overload to cast the returned element to a more specific type.
+ // Eg: var name = this.refs['name'].getDOMNode().value;
+ getDOMNode(): TElement;
+ getDOMNode(): Element;
+ isMounted(): boolean;
+
props: P;
+ setProps(nextProps: P, callback?: () => void): void;
+ replaceProps(nextProps: P, callback?: () => void): void;
}
- export interface ReactHTMLElement extends ReactDOMElement {
+ interface DOMComponent extends Component
{
+ tagName: string;
}
- export interface ReactSVGElement extends ReactDOMElement {
+ interface HTMLComponent extends DOMComponent {}
+ interface SVGComponent extends DOMComponent {}
+
+ interface CompositeComponent extends Component, ComponentSpec {
+ state: S;
+ setState(nextState: S, callback?: () => void): void;
+ replaceState(nextState: S, callback?: () => void): void;
+ forceUpdate(callback?: () => void): void;
+ refs: {
+ [key: string]: Component
+ };
}
- export interface ReactComponentElement extends ReactElement, P> {
- props: P;
- }
+ //
+ // Component Specs and Lifecycle
+ // ----------------------------------------------------------------------
- export interface Mixin {
+ interface Mixin extends ComponentStatics {
+ mixins?: Mixin;
+ statics?: {
+ [key: string]: any;
+ };
+
+ // Definition methods
+ getInitialState?(): S;
+
+ // Delegate methods
componentWillMount?(): void;
componentDidMount?(): void;
componentWillReceiveProps?(nextProps: P): void;
@@ -103,114 +129,21 @@ declare module React {
componentWillUnmount?(): void;
}
- export interface Specification extends Mixin {
- displayName?: string;
- mixins?: Mixin[];
- statics?: {
- [key: string]: Function;
- };
- propTypes?: ValidationMap;
- getDefaultProps?(): P;
- getInitialState?(): S;
- render(): ReactElement;
+ interface ComponentSpec extends Mixin {
+ render(): ReactElement;
}
- export interface DomReferencer {
- getDOMNode(): Element;
- /**
- * Use this overload to cast the returned element to a more specific type.
- * Eg: var name = this.refs['name'].getDOMNode().value
- */
- getDOMNode(): TElement;
- }
+ //
+ // Event System
+ // ----------------------------------------------------------------------
- export interface Component extends DomReferencer {
- refs: {
- [key: string]: DomReferencer
- };
- props: P;
- state: S;
- setState(nextState: S, callback?: () => void): void;
- replaceState(nextState: S, callback?: () => void): void;
- forceUpdate(callback?: () => void): void;
- isMounted(): boolean;
- setProps(nextProps: P, callback?: () => void): void;
- replaceProps(nextProps: P, callback?: () => void): void;
- }
-
- export interface Constructable {
- new(): any;
- }
-
- export interface Validator {
- (props: P, propName: string, componentName: string): Error;
- }
-
- export interface Requireable
extends Validator
{
- isRequired: Validator
;
- }
-
- export interface ValidationMap
{
- [key: string]: Validator
;
- }
-
- export var PropTypes: {
- any: Requireable;
- array: Requireable;
- bool: Requireable;
- func: Requireable;
- number: Requireable;
- object: Requireable;
- string: Requireable;
- node: Requireable;
- component: Requireable;
- instanceOf: (clazz: Constructable) => Requireable;
- oneOf: (types: any[]) => Requireable
- oneOfType: (types: Validator[]) => Requireable;
- arrayOf: (type: Validator) => Requireable;
- objectOf: (type: Validator) => Requireable;
- shape: (type: ValidationMap) => Requireable;
- };
-
- export var Children: {
- map(children: any[], fn: (child: any) => any): any[];
- forEach(children: any[], fn: (child: any) => any): void;
- count(children: any[]): number;
- only(children: any[]): any;
- };
-
- // Browser Interfaces
- // Taken from https://github.com/nikeee/2048-typescript/blob/master/2048/js/touch.d.ts
- export interface AbstractView {
- styleMedia: StyleMedia;
- document: Document;
- }
-
- export interface Touch {
- identifier: number;
- target: EventTarget;
- screenX: number;
- screenY: number;
- clientX: number;
- clientY: number;
- pageX: number;
- pageY: number;
- }
-
- export interface TouchList {
- [index: number]: Touch;
- length: number;
- item(index: number): Touch;
- identifiedTouch(identifier: number): Touch;
- }
-
- // Events
- export interface SyntheticEvent {
+ interface SyntheticEvent {
bubbles: boolean;
cancelable: boolean;
currentTarget: EventTarget;
defaultPrevented: boolean;
eventPhase: number;
+ isTrusted: boolean;
nativeEvent: Event;
preventDefault(): void;
stopPropagation(): void;
@@ -219,11 +152,11 @@ declare module React {
type: string;
}
- export interface ClipboardEvent extends SyntheticEvent {
+ interface ClipboardEvent extends SyntheticEvent {
clipboardData: DataTransfer;
}
- export interface KeyboardEvent extends SyntheticEvent {
+ interface KeyboardEvent extends SyntheticEvent {
altKey: boolean;
charCode: number;
ctrlKey: boolean;
@@ -238,11 +171,14 @@ declare module React {
which: number;
}
- export interface FocusEvent extends SyntheticEvent {
+ interface FocusEvent extends SyntheticEvent {
relatedTarget: EventTarget;
}
- export interface MouseEvent extends SyntheticEvent {
+ interface FormEvent extends SyntheticEvent {
+ }
+
+ interface MouseEvent extends SyntheticEvent {
altKey: boolean;
button: number;
buttons: number;
@@ -259,7 +195,7 @@ declare module React {
shiftKey: boolean;
}
- export interface TouchEvent extends SyntheticEvent {
+ interface TouchEvent extends SyntheticEvent {
altKey: boolean;
changedTouches: TouchList;
ctrlKey: boolean;
@@ -270,343 +206,721 @@ declare module React {
touches: TouchList;
}
- export interface UiEvent extends SyntheticEvent {
+ interface UIEvent extends SyntheticEvent {
detail: number;
view: AbstractView;
}
- export interface WheelEvent extends SyntheticEvent {
+ interface WheelEvent extends SyntheticEvent {
deltaMode: number;
deltaX: number;
deltaY: number;
deltaZ: number;
}
- // Attributes
- export interface EventAttributes {
- onCopy?: (event: ClipboardEvent) => void;
- onCut?: (event: ClipboardEvent) => void;
- onPaste?: (event: ClipboardEvent) => void;
- onKeyDown?: (event: KeyboardEvent) => void;
- onKeyPress?: (event: KeyboardEvent) => void;
- onKeyUp?: (event: KeyboardEvent) => void;
- onFocus?: (event: FocusEvent) => void;
- onBlur?: (event: FocusEvent) => void;
- onChange?: (event: SyntheticEvent) => void;
- onInput?: (event: SyntheticEvent) => void;
- onSubmit?: (event: SyntheticEvent) => void;
- onClick?: (event: MouseEvent) => void;
- onDoubleClick?: (event: MouseEvent) => void;
- onDrag?: (event: MouseEvent) => void;
- onDragEnd?: (event: MouseEvent) => void;
- onDragEnter?: (event: MouseEvent) => void;
- onDragExit?: (event: MouseEvent) => void;
- onDragLeave?: (event: MouseEvent) => void;
- onDragOver?: (event: MouseEvent) => void;
- onDragStart?: (event: MouseEvent) => void;
- onDrop?: (event: MouseEvent) => void;
- onMouseDown?: (event: MouseEvent) => void;
- onMouseEnter?: (event: MouseEvent) => void;
- onMouseLeave?: (event: MouseEvent) => void;
- onMouseMove?: (event: MouseEvent) => void;
- onMouseOut?: (event: MouseEvent) => void;
- onMouseOver?: (event: MouseEvent) => void;
- onMouseUp?: (event: MouseEvent) => void;
- onTouchCancel?: (event: TouchEvent) => void;
- onTouchEnd?: (event: TouchEvent) => void;
- onTouchMove?: (event: TouchEvent) => void;
- onTouchStart?: (event: TouchEvent) => void;
- onScroll?: (event: UiEvent) => void;
- onWheel?: (event: WheelEvent) => void;
+ //
+ // Event Handler Types
+ // ----------------------------------------------------------------------
+
+ interface EventHandler {
+ (event: E): void;
}
+ interface ClipboardEventHandler extends EventHandler {}
+ interface KeyboardEventHandler extends EventHandler {}
+ interface FocusEventHandler extends EventHandler {}
+ interface FormEventHandler extends EventHandler {}
+ interface MouseEventHandler extends EventHandler {}
+ interface TouchEventHandler extends EventHandler {}
+ interface UIEventHandler extends EventHandler {}
+ interface WheelEventHandler extends EventHandler {}
+
+ //
+ // Attributes
+ // ----------------------------------------------------------------------
+
export interface ReactAttributes {
- dangerouslySetInnerHTML?: {
- __html: string;
- };
- children?: any[];
+ children?: any; // ReactNode
key?: string;
ref?: string;
+
+ // Event Attributes
+ onCopy?: ClipboardEventHandler;
+ onCut?: ClipboardEventHandler;
+ onPaste?: ClipboardEventHandler;
+ onKeyDown?: KeyboardEventHandler;
+ onKeyPress?: KeyboardEventHandler;
+ onKeyUp?: KeyboardEventHandler;
+ onFocus?: FocusEventHandler;
+ onBlur?: FocusEventHandler;
+ onChange?: FormEventHandler;
+ onInput?: FormEventHandler;
+ onSubmit?: FormEventHandler;
+ onClick?: MouseEventHandler;
+ onDoubleClick?: MouseEventHandler;
+ onDrag?: MouseEventHandler;
+ onDragEnd?: MouseEventHandler;
+ onDragEnter?: MouseEventHandler;
+ onDragExit?: MouseEventHandler;
+ onDragLeave?: MouseEventHandler;
+ onDragOver?: MouseEventHandler;
+ onDragStart?: MouseEventHandler;
+ onDrop?: MouseEventHandler;
+ onMouseDown?: MouseEventHandler;
+ onMouseEnter?: MouseEventHandler;
+ onMouseLeave?: MouseEventHandler;
+ onMouseMove?: MouseEventHandler;
+ onMouseOut?: MouseEventHandler;
+ onMouseOver?: MouseEventHandler;
+ onMouseUp?: MouseEventHandler;
+ onTouchCancel?: TouchEventHandler;
+ onTouchEnd?: TouchEventHandler;
+ onTouchMove?: TouchEventHandler;
+ onTouchStart?: TouchEventHandler;
+ onScroll?: UIEventHandler;
+ onWheel?: WheelEventHandler;
+
+ dangerouslySetInnerHTML?: {
+ __html: string
+ };
}
- export interface DomAttributes extends EventAttributes, ReactAttributes {
- // HTML Attributes
- accept?: any;
- accessKey?: any;
- action?: any;
- allowFullScreen?: any;
- allowTransparency?: any;
- alt?: any;
- async?: any;
- autoCapitalize?: any;
- autoComplete?: any;
- autoCorrect?: any;
- autoFocus?: any;
- autoPlay?: any;
- cellPadding?: any;
- cellSpacing?: any;
- charSet?: any;
- checked?: any;
- className?: any;
- cols?: any;
- colSpan?: any;
- content?: any;
- contentEditable?: any;
- contextMenu?: any;
+ interface CSSProperties {
+ columnCount?: number;
+ flex?: number;
+ flexGrow?: number;
+ flexShrink?: number;
+ fontWeight?: number;
+ lineClamp?: number;
+ lineHeight?: number;
+ opacity?: number;
+ order?: number;
+ orphans?: number;
+ widows?: number;
+ zIndex?: number;
+ zoom?: number;
+
+ // SVG-related properties
+ fillOpacity?: number;
+ strokeOpacity?: number;
+
+ [key: string]: any; // number | string
+ }
+
+ interface HTMLAttributes extends ReactAttributes {
+ accept?: string;
+ acceptCharset?: string;
+ accessKey?: string;
+ action?: string;
+ allowFullScreen?: boolean;
+ allowTransparency?: boolean;
+ alt?: string;
+ async?: boolean;
+ autoComplete?: boolean;
+ autoFocus?: boolean;
+ autoPlay?: boolean;
+ cellPadding?: any; // number | string
+ cellSpacing?: any; // number | string
+ charSet?: string;
+ checked?: boolean;
+ classID?: string;
+ className?: string;
+ cols?: number;
+ colSpan?: number;
+ content?: string;
+ contentEditable?: boolean;
+ contextMenu?: string;
controls?: any;
- coords?: any;
- crossOrigin?: any;
- data?: any;
- dateTime?: any;
- defer?: any;
- dir?: any;
- disabled?: any;
+ coords?: string;
+ crossOrigin?: string;
+ data?: string;
+ dateTime?: string;
+ defer?: boolean;
+ dir?: string;
+ disabled?: boolean;
download?: any;
- draggable?: any;
- encType?: any;
- form?: any;
- formNoValidate?: any;
- frameBorder?: any;
- height?: any;
- hidden?: any;
- href?: any;
- hrefLang?: any;
- htmlFor?: any;
- httpEquiv?: any;
- icon?: any;
- id?: any;
- itemProp?: any;
- itemScope?: any;
- itemType?: any;
- label?: any;
- lang?: any;
- list?: any;
- loop?: any;
- max?: any;
- maxLength?: any;
- mediaGroup?: any;
- method?: any;
- min?: any;
- multiple?: any;
- muted?: any;
- name?: any;
- noValidate?: any;
- open?: any;
- pattern?: any;
- placeholder?: any;
- poster?: any;
- preload?: any;
- property?: any;
- radioGroup?: any;
- readOnly?: any;
- rel?: any;
- required?: any;
- role?: any;
- rows?: any;
- rowSpan?: any;
- sandbox?: any;
- scope?: any;
- scrollLeft?: any;
- scrolling?: any;
- scrollTop?: any;
- seamless?: any;
- selected?: any;
- shape?: any;
- size?: any;
- span?: any;
- spellCheck?: any;
- src?: any;
- srcDoc?: any;
- srcSet?: any;
- start?: any;
- step?: any;
- style?: any;
- tabIndex?: any;
- target?: any;
- title?: any;
- type?: any;
- useMap?: any;
- value?: any;
- width?: any;
- wmode?: any;
+ draggable?: boolean;
+ encType?: string;
+ form?: string;
+ formNoValidate?: boolean;
+ frameBorder?: any; // number | string
+ height?: any; // number | string
+ hidden?: boolean;
+ href?: string;
+ hrefLang?: string;
+ htmlFor?: string;
+ httpEquiv?: string;
+ icon?: string;
+ id?: string;
+ label?: string;
+ lang?: string;
+ list?: string;
+ loop?: boolean;
+ manifest?: string;
+ max?: any; // number | string
+ maxLength?: number;
+ media?: string;
+ mediaGroup?: string;
+ method?: string;
+ min?: any; // number | string
+ multiple?: boolean;
+ muted?: boolean;
+ name?: string;
+ noValidate?: boolean;
+ open?: boolean;
+ pattern?: string;
+ placeholder?: string;
+ poster?: string;
+ preload?: string;
+ radioGroup?: string;
+ readOnly?: boolean;
+ rel?: string;
+ required?: boolean;
+ role?: string;
+ rows?: number;
+ rowSpan?: number;
+ sandbox?: string;
+ scope?: string;
+ scrollLeft?: number;
+ scrolling?: string;
+ scrollTop?: number;
+ seamless?: boolean;
+ selected?: boolean;
+ shape?: string;
+ size?: number;
+ sizes?: string;
+ span?: number;
+ spellCheck?: boolean;
+ src?: string;
+ srcDoc?: string;
+ srcSet?: string;
+ start?: number;
+ step?: any; // number | string
+ style?: CSSProperties;
+ tabIndex?: number;
+ target?: string;
+ title?: string;
+ type?: string;
+ useMap?: string;
+ value?: string;
+ width?: any; // number | string
+ wmode?: string;
+
+ // Non-standard Attributes
+ autoCapitalize?: boolean;
+ autoCorrect?: boolean;
+ property?: string;
+ itemProp?: string;
+ itemScope?: boolean;
+ itemType?: string;
}
- export interface SvgAttributes extends EventAttributes, ReactAttributes {
- cx?: any;
- cy?: any;
- d?: any;
- dx?: any;
- dy?: any;
- fill?: any;
- fillOpacity?: any;
- fontFamily?: any;
- fontSize?: any;
- fx?: any;
- fy?: any;
- gradientTransform?: any;
- gradientUnits?: any;
- markerEnd?: any;
- markerMid?: any;
- markerStart?: any;
- offset?: any;
- opacity?: any;
- patternContentUnits?: any;
- patternUnits?: any;
- points?: any;
- preserveAspectRatio?: any;
- r?: any;
- rx?: any;
- ry?: any;
- spreadMethod?: any;
- stopColor?: any;
- stopOpacity?: any;
- stroke?: any;
- strokeDasharray?: any;
- strokeLinecap?: any;
- strokeOpacity?: any;
- strokeWidth?: any;
- textAnchor?: any;
- transform?: any;
- version?: any;
- viewBox?: any;
- x1?: any;
- x2?: any;
- x?: any;
- y1?: any;
- y2?: any;
- y?: any;
+ interface SVGAttributes extends ReactAttributes {
+ cx?: any; // SVGLength | SVGAnimatedLength
+ cy?: any;
+ d?: string;
+ dx?: any; // SVGLength | SVGAnimatedLength
+ dy?: any; // SVGLength | SVGAnimatedLength
+ fill?: any; // SVGPaint | string
+ fillOpacity?: any; // number | string
+ fontFamily?: string;
+ fontSize?: any; // number | string
+ fx?: any; // SVGLength | SVGAnimatedLength
+ fy?: any; // SVGLength | SVGAnimatedLength
+ gradientTransform?: any; // SVGTransformList | SVGAnimatedTransformList
+ gradientUnits?: string;
+ markerEnd?: string;
+ markerMid?: string;
+ markerStart?: string;
+ offset?: any; // number | string
+ opacity?: any; // number | string
+ patternContentUnits?: string;
+ patternUnits?: string;
+ points?: string;
+ preserveAspectRatio?: string;
+ r?: any; // SVGLength | SVGAnimatedLength
+ rx?: any; // SVGLength | SVGAnimatedLength
+ ry?: any; // SVGLength | SVGAnimatedLength
+ spreadMethod?: string;
+ stopColor?: any; // SVGColor | string
+ stopOpacity?: any; // number | string
+ stroke?: any; // SVGPaint
+ strokeDasharray?: string;
+ strokeLinecap?: string;
+ strokeOpacity?: any; // number | string
+ strokeWidth?: any; // SVGLength | SVGAnimatedLength
+ textAnchor?: string;
+ transform?: any; // SVGTransformList | SVGAnimatedTransformList
+ version?: string;
+ viewBox?: string;
+ x1?: any; // SVGLength | SVGAnimatedLength
+ x2?: any; // SVGLength | SVGAnimatedLength
+ x?: any; // SVGLength | SVGAnimatedLength
+ y1?: any; // SVGLength | SVGAnimatedLength
+ y2?: any; // SVGLength | SVGAnimatedLength
+ y?: any; // SVGLength | SVGAnimatedLength
}
- export var DOM: {
+ //
+ // React.DOM
+ // ----------------------------------------------------------------------
+
+ interface ReactDOM {
// HTML
- a: DomElement;
- abbr: DomElement;
- address: DomElement;
- area: DomElement;
- article: DomElement;
- aside: DomElement;
- audio: DomElement;
- b: DomElement;
- base: DomElement;
- bdi: DomElement;
- bdo: DomElement;
- big: DomElement;
- blockquote: DomElement;
- body: DomElement;
- br: DomElement;
- button: DomElement;
- canvas: DomElement;
- caption: DomElement;
- cite: DomElement;
- code: DomElement;
- col: DomElement;
- colgroup: DomElement;
- data: DomElement;
- datalist: DomElement;
- dd: DomElement;
- del: DomElement;
- details: DomElement;
- dfn: DomElement;
- dialog: DomElement;
- div: DomElement;
- dl: DomElement;
- dt: DomElement;
- em: DomElement;
- embed: DomElement;
- fieldset: DomElement;
- figcaption: DomElement;
- figure: DomElement;
- footer: DomElement;
- form: DomElement;
- h1: DomElement;
- h2: DomElement;
- h3: DomElement;
- h4: DomElement;
- h5: DomElement;
- h6: DomElement;
- head: DomElement;
- header: DomElement;
- hr: DomElement;
- html: DomElement;
- i: DomElement;
- iframe: DomElement;
- img: DomElement;
- input: DomElement;
- ins: DomElement;
- kbd: DomElement;
- keygen: DomElement;
- label: DomElement;
- legend: DomElement;
- li: DomElement;
- link: DomElement;
- main: DomElement;
- map: DomElement;
- mark: DomElement;
- menu: DomElement;
- menuitem: DomElement;
- meta: DomElement;
- meter: DomElement;
- nav: DomElement;
- noscript: DomElement;
- object: DomElement;
- ol: DomElement;
- optgroup: DomElement;
- option: DomElement;
- output: DomElement;
- p: DomElement;
- param: DomElement;
- pre: DomElement;
- progress: DomElement;
- q: DomElement;
- rp: DomElement;
- rt: DomElement;
- ruby: DomElement;
- s: DomElement;
- samp: DomElement;
- script: DomElement;
- section: DomElement;
- select: DomElement;
- small: DomElement;
- source: DomElement;
- span: DomElement;
- strong: DomElement;
- style: DomElement;
- sub: DomElement;
- summary: DomElement;
- sup: DomElement;
- table: DomElement;
- tbody: DomElement;
- td: DomElement;
- textarea: DomElement;
- tfoot: DomElement;
- th: DomElement;
- thead: DomElement;
- time: DomElement;
- title: DomElement;
- tr: DomElement;
- track: DomElement;
- u: DomElement;
- ul: DomElement;
- "var": DomElement;
- video: DomElement;
- wbr: DomElement;
+ a: HTMLFactory;
+ abbr: HTMLFactory;
+ address: HTMLFactory;
+ area: HTMLFactory;
+ article: HTMLFactory;
+ aside: HTMLFactory;
+ audio: HTMLFactory;
+ b: HTMLFactory;
+ base: HTMLFactory;
+ bdi: HTMLFactory;
+ bdo: HTMLFactory;
+ big: HTMLFactory;
+ blockquote: HTMLFactory;
+ body: HTMLFactory;
+ br: HTMLFactory;
+ button: HTMLFactory;
+ canvas: HTMLFactory;
+ caption: HTMLFactory;
+ cite: HTMLFactory;
+ code: HTMLFactory;
+ col: HTMLFactory;
+ colgroup: HTMLFactory;
+ data: HTMLFactory;
+ datalist: HTMLFactory;
+ dd: HTMLFactory;
+ del: HTMLFactory;
+ details: HTMLFactory;
+ dfn: HTMLFactory;
+ dialog: HTMLFactory;
+ div: HTMLFactory;
+ dl: HTMLFactory;
+ dt: HTMLFactory;
+ em: HTMLFactory;
+ embed: HTMLFactory;
+ fieldset: HTMLFactory;
+ figcaption: HTMLFactory;
+ figure: HTMLFactory;
+ footer: HTMLFactory;
+ form: HTMLFactory;
+ h1: HTMLFactory;
+ h2: HTMLFactory;
+ h3: HTMLFactory;
+ h4: HTMLFactory;
+ h5: HTMLFactory;
+ h6: HTMLFactory;
+ head: HTMLFactory;
+ header: HTMLFactory;
+ hr: HTMLFactory;
+ html: HTMLFactory;
+ i: HTMLFactory;
+ iframe: HTMLFactory;
+ img: HTMLFactory;
+ input: HTMLFactory;
+ ins: HTMLFactory;
+ kbd: HTMLFactory;
+ keygen: HTMLFactory;
+ label: HTMLFactory;
+ legend: HTMLFactory;
+ li: HTMLFactory;
+ link: HTMLFactory;
+ main: HTMLFactory;
+ map: HTMLFactory;
+ mark: HTMLFactory;
+ menu: HTMLFactory;
+ menuitem: HTMLFactory;
+ meta: HTMLFactory;
+ meter: HTMLFactory;
+ nav: HTMLFactory;
+ noscript: HTMLFactory;
+ object: HTMLFactory;
+ ol: HTMLFactory;
+ optgroup: HTMLFactory;
+ option: HTMLFactory;
+ output: HTMLFactory;
+ p: HTMLFactory;
+ param: HTMLFactory;
+ picture: HTMLFactory;
+ pre: HTMLFactory;
+ progress: HTMLFactory;
+ q: HTMLFactory;
+ rp: HTMLFactory;
+ rt: HTMLFactory;
+ ruby: HTMLFactory;
+ s: HTMLFactory;
+ samp: HTMLFactory;
+ script: HTMLFactory;
+ section: HTMLFactory;
+ select: HTMLFactory;
+ small: HTMLFactory;
+ source: HTMLFactory;
+ span: HTMLFactory;
+ strong: HTMLFactory;
+ style: HTMLFactory;
+ sub: HTMLFactory;
+ summary: HTMLFactory;
+ sup: HTMLFactory;
+ table: HTMLFactory;
+ tbody: HTMLFactory;
+ td: HTMLFactory;
+ textarea: HTMLFactory;
+ tfoot: HTMLFactory;
+ th: HTMLFactory;
+ thead: HTMLFactory;
+ time: HTMLFactory;
+ title: HTMLFactory;
+ tr: HTMLFactory;
+ track: HTMLFactory;
+ u: HTMLFactory;
+ ul: HTMLFactory;
+ "var": HTMLFactory;
+ video: HTMLFactory;
+ wbr: HTMLFactory;
+
// SVG
- circle: SvgElement;
- defs: SvgElement;
- ellipse: SvgElement;
- g: SvgElement;
- line: SvgElement;
- linearGradient: SvgElement;
- mask: SvgElement;
- path: SvgElement;
- pattern: SvgElement;
- polygon: SvgElement;
- polyline: SvgElement;
- radialGradient: SvgElement;
- rect: SvgElement;
- stop: SvgElement;
- svg: SvgElement;
- text: SvgElement;
- tspan: SvgElement;
- };
+ circle: SVGFactory;
+ defs: SVGFactory;
+ ellipse: SVGFactory;
+ g: SVGFactory;
+ line: SVGFactory;
+ linearGradient: SVGFactory;
+ mask: SVGFactory;
+ path: SVGFactory;
+ pattern: SVGFactory;
+ polygon: SVGFactory;
+ polyline: SVGFactory;
+ radialGradient: SVGFactory;
+ rect: SVGFactory;
+ stop: SVGFactory;
+ svg: SVGFactory;
+ text: SVGFactory;
+ tspan: SVGFactory;
+ }
+
+ //
+ // React.PropTypes
+ // ----------------------------------------------------------------------
+
+ interface Validator {
+ (object: T, key: string, componentName: string): Error;
+ }
+
+ interface Requireable extends Validator {
+ isRequired: Validator;
+ }
+
+ interface ValidationMap {
+ [key: string]: Validator;
+ }
+
+ interface ReactPropTypes {
+ any: Requireable;
+ array: Requireable;
+ bool: Requireable;
+ func: Requireable;
+ number: Requireable;
+ object: Requireable;
+ string: Requireable;
+ node: Requireable;
+ element: Requireable;
+ instanceOf(expectedClass: {}): Requireable;
+ oneOf(types: any[]): Requireable;
+ oneOfType(types: Validator[]): Requireable;
+ arrayOf(type: Validator): Requireable;
+ objectOf(type: Validator): Requireable;
+ shape(type: ValidationMap): Requireable;
+ }
+
+ //
+ // React.Children
+ // ----------------------------------------------------------------------
+
+ interface ReactChildren {
+ map(children: any/*ReactNode*/, fn: (child: any/*ReactNode*/) => T): { [key:string]: T };
+ forEach(children: any/*ReactNode*/, fn: (child: any/*ReactNode*/) => any): void;
+ count(children: any/*ReactNode*/): number;
+ only(children: any/*ReactNode*/): any;
+ }
+
+ //
+ // React.addons (Transitions)
+ // ----------------------------------------------------------------------
+
+ interface CSSTransitionGroupProps {
+ transitionName: string;
+ transitionAppear?: boolean;
+ transitionEnter?: boolean;
+ transitionLeave?: boolean;
+ }
+
+ interface TransitionGroupProps {
+ component?: any; // ReactType
+ childFactory?: (child: ReactElement) => ReactElement;
+ }
+
+ interface CSSTransitionGroup extends ComponentClass {}
+ interface TransitionGroup extends ComponentClass {}
+
+ //
+ // React.addons (Mixins)
+ // ----------------------------------------------------------------------
+
+ interface ReactLink {
+ value: T;
+ requestChange(newValue: T): void;
+ }
+
+ interface LinkedStateMixin extends Mixin {
+ linkState(key: string): ReactLink;
+ }
+
+ interface PureRenderMixin extends Mixin {
+ }
+
+ //
+ // Reat.addons.update
+ // ----------------------------------------------------------------------
+
+ interface UpdateSpec {
+ $set: any;
+ $merge: {};
+ $apply(value: any): any;
+ // [key: string]: UpdateSpec;
+ }
+
+ interface UpdateArraySpec extends UpdateSpec {
+ $push?: any[];
+ $unshift?: any[];
+ $splice?: any[][];
+ }
+
+ //
+ // React.addons.Perf
+ // ----------------------------------------------------------------------
+
+ interface ComponentPerfContext {
+ current: string;
+ owner: string;
+ }
+
+ interface NumericPerfContext {
+ [key: string]: number;
+ }
+
+ interface Measurements {
+ exclusive: NumericPerfContext;
+ inclusive: NumericPerfContext;
+ render: NumericPerfContext;
+ counts: NumericPerfContext;
+ writes: NumericPerfContext;
+ displayNames: {
+ [key: string]: ComponentPerfContext;
+ };
+ totalTime: number;
+ }
+
+ interface ReactPerf {
+ start(): void;
+ stop(): void;
+ printInclusive(measurements: Measurements[]): void;
+ printExclusive(measurements: Measurements[]): void;
+ printWasted(measurements: Measurements[]): void;
+ printDOM(measurements: Measurements[]): void;
+ getLastMeasurements(): Measurements[];
+ }
+
+ //
+ // React.addons.TestUtils
+ // ----------------------------------------------------------------------
+
+ interface MockedComponentClass {
+ new(): any;
+ }
+
+ interface ReactTestUtils {
+ Simulate: Simulate;
+
+ renderIntoDocument(element: ReactElement
): Component
;
+ renderIntoDocument>(element: ReactElement): C;
+
+ mockComponent(mocked: MockedComponentClass, mockTagName?: string): ReactTestUtils;
+
+ isElementOfType(element: ReactElement, type: any/*ReactType*/): boolean;
+ isDOMComponent(instance: Component): boolean;
+ isCompositeComponent(instance: Component): boolean;
+ isCompositeComponentWithType(instance: Component, type: ComponentClass): boolean;
+ isTextComponent(instance: Component): boolean;
+
+ findAllInRenderedTree(tree: Component, fn: (i: Component) => boolean): Component;
+
+ scryRenderedDOMComponentsWithClass(tree: Component, className: string): DOMComponent[];
+ findRenderedDOMComponentWithClass(tree: Component, className: string): DOMComponent;
+
+ scryRenderedDOMComponentsWithTag(tree: Component, tagName: string): DOMComponent[];
+ findRenderedDOMComponentWithTag(tree: Component, tagName: string): DOMComponent;
+
+ scryRenderedComponentsWithType(
+ tree: Component, type: ComponentClass): CompositeComponent[];
+ scryRenderedComponentsWithType>(
+ tree: Component, type: ComponentClass): C[];
+
+ findRenderedComponentWithType(
+ tree: Component, type: ComponentClass): CompositeComponent;
+ findRenderedComponentWithType>(
+ tree: Component, type: ComponentClass): C;
+ }
+
+ interface SyntheticEventData {
+ altKey?: boolean;
+ button?: number;
+ buttons?: number;
+ clientX?: number;
+ clientY?: number;
+ changedTouches?: TouchList;
+ charCode?: boolean;
+ clipboardData?: DataTransfer;
+ ctrlKey?: boolean;
+ deltaMode?: number;
+ deltaX?: number;
+ deltaY?: number;
+ deltaZ?: number;
+ detail?: number;
+ getModifierState?(key: string): boolean;
+ key?: string;
+ keyCode?: number;
+ locale?: string;
+ location?: number;
+ metaKey?: boolean;
+ pageX?: number;
+ pageY?: number;
+ relatedTarget?: EventTarget;
+ repeat?: boolean;
+ screenX?: number;
+ screenY?: number;
+ shiftKey?: boolean;
+ targetTouches?: TouchList;
+ touches?: TouchList;
+ view?: AbstractView;
+ which?: number;
+ }
+
+ interface EventSimulator {
+ (element: Element, eventData?: SyntheticEventData): void;
+ (descriptor: Component, eventData?: SyntheticEventData): void;
+ }
+
+ interface Simulate {
+ blur: EventSimulator;
+ change: EventSimulator;
+ click: EventSimulator;
+ cut: EventSimulator;
+ doubleClick: EventSimulator;
+ drag: EventSimulator;
+ dragEnd: EventSimulator;
+ dragEnter: EventSimulator;
+ dragExit: EventSimulator;
+ dragLeave: EventSimulator;
+ dragOver: EventSimulator;
+ dragStart: EventSimulator;
+ drop: EventSimulator;
+ focus: EventSimulator;
+ input: EventSimulator;
+ keyDown: EventSimulator;
+ keyPress: EventSimulator;
+ keyUp: EventSimulator;
+ mouseDown: EventSimulator;
+ mouseEnter: EventSimulator;
+ mouseLeave: EventSimulator;
+ mouseMove: EventSimulator;
+ mouseOut: EventSimulator;
+ mouseOver: EventSimulator;
+ mouseUp: EventSimulator;
+ paste: EventSimulator;
+ scroll: EventSimulator;
+ submit: EventSimulator;
+ touchCancel: EventSimulator;
+ touchEnd: EventSimulator;
+ touchMove: EventSimulator;
+ touchStart: EventSimulator;
+ wheel: EventSimulator;
+ }
+
+ //
+ // react Exports
+ // ----------------------------------------------------------------------
+
+ interface Exports extends TopLevelAPI {
+ DOM: ReactDOM;
+ PropTypes: ReactPropTypes;
+ Children: ReactChildren;
+ }
+
+ //
+ // react/addons Exports
+ // ----------------------------------------------------------------------
+
+ interface AddonsExports extends Exports {
+ addons: {
+ CSSTransitionGroup: CSSTransitionGroup;
+ LinkedStateMixin: LinkedStateMixin;
+ PureRenderMixin: PureRenderMixin;
+ TransitionGroup: TransitionGroup;
+
+ batchedUpdates(callback: (a: A, b: B) => void, a: A, b: B): void;
+ batchedUpdates(callback: (a: A) => void, a: A): void;
+ batchedUpdates(callback: () => void): void;
+
+ classSet(cx: { [key: string]: boolean }): string;
+ cloneWithProps(element: ReactElement
, props: P): ReactElement
;
+
+ update(value: any[], spec: UpdateArraySpec): any[];
+ update(value: {}, spec: UpdateSpec): any;
+
+ // Development tools
+ Perf: ReactPerf;
+ TestUtils: ReactTestUtils;
+ };
+ }
+
+ //
+ // Browser Interfaces
+ // https://github.com/nikeee/2048-typescript/blob/master/2048/js/touch.d.ts
+ // ----------------------------------------------------------------------
+
+ interface AbstractView {
+ styleMedia: StyleMedia;
+ document: Document;
+ }
+
+ interface Touch {
+ identifier: number;
+ target: EventTarget;
+ screenX: number;
+ screenY: number;
+ clientX: number;
+ clientY: number;
+ pageX: number;
+ pageY: number;
+ }
+
+ interface TouchList {
+ [index: number]: Touch;
+ length: number;
+ item(index: number): Touch;
+ identifiedTouch(identifier: number): Touch;
+ }
}
+
+declare module "react" {
+ var exports: React.Exports;
+ export = exports;
+}
+
+declare module "react/addons" {
+ var exports: React.AddonsExports;
+ export = exports;
+}
+