From 1d663ab9a3fc61c6570cb809ac5c6bfc99c6578d Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 12:09:56 -0700
Subject: [PATCH 01/10] Moving React 0.11 into legacy

I'm following the example from Angular.
---
 .../legacy/react-addons-0.11-tests.ts         | 133 +++++
 react-addons/legacy/react-addons-0.11.d.ts    | 172 ++++++
 react/legacy/react-0.11-tests.ts              | 107 ++++
 react/legacy/react-0.11.d.ts                  | 553 ++++++++++++++++++
 4 files changed, 965 insertions(+)
 create mode 100644 react-addons/legacy/react-addons-0.11-tests.ts
 create mode 100644 react-addons/legacy/react-addons-0.11.d.ts
 create mode 100644 react/legacy/react-0.11-tests.ts
 create mode 100644 react/legacy/react-0.11.d.ts

diff --git a/react-addons/legacy/react-addons-0.11-tests.ts b/react-addons/legacy/react-addons-0.11-tests.ts
new file mode 100644
index 000000000..2c5c781d7
--- /dev/null
+++ b/react-addons/legacy/react-addons-0.11-tests.ts
@@ -0,0 +1,133 @@
+/// <reference path="react-addons-0.11.d.ts" />
+import React = require("react/addons");
+
+var PropTypesSpecification: React.Specification<any, any> = {
+    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.renderable,
+
+        // 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.
+        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
+        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) {
+            if (!/matchme/.test(props[propName])) {
+                return new Error('Validation failed!');
+            }
+            return null;
+        }
+    },
+    render: (): React.Descriptor<any> => {
+        return null;
+    }
+};
+
+React.createClass(PropTypesSpecification);
+
+var mountNode: Element;
+
+var HelloMessage = React.createClass({displayName: 'HelloMessage',
+    render: function() {
+        return React.DOM.div(null, "Hello ", (<React.Component<{name: string}, any>>this).props.name);
+    }
+});
+
+React.renderComponent(HelloMessage({name: "John"}), mountNode);
+
+var Timer = React.createClass({displayName: 'Timer',
+    getInitialState: function() {
+        return {secondsElapsed: 0};
+    },
+    tick: function() {
+        (<React.Component<any, {secondsElapsed: number}>>this).setState({
+            secondsElapsed: (<React.Component<any, {secondsElapsed: number}>>this).state.secondsElapsed + 1
+        });
+    },
+    componentDidMount: function() {
+        this.interval = setInterval(this.tick, 1000);
+    },
+    componentWillUnmount: function() {
+        clearInterval(this.interval);
+    },
+    render: function() {
+        return React.DOM.div(
+            null,
+            "Seconds Elapsed: ",
+            (<React.Component<any, {secondsElapsed: number}>>this).state.secondsElapsed
+        );
+    }
+});
+
+React.renderComponent(Timer(null), mountNode);
+
+// TestUtils
+var that: React.Component<any, any>;
+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"});
+
+var GoodbyeMessage = React.createClass({displayName: 'GoodbyeMessage',
+    render: function() {
+        return React.DOM.div(null, "Goodbye ", (<React.Component<{name: string}, any>>this).props.name);
+    }
+});
+React.addons.TestUtils.renderIntoDocument(GoodbyeMessage({name: "John"}));
+
+var isImportant: boolean;
+var isRead: boolean;
+var cx = React.addons.classSet;
+var classes = cx({
+    'message': true,
+    'message-important': isImportant,
+    'message-read': isRead
+});
+
+
+
diff --git a/react-addons/legacy/react-addons-0.11.d.ts b/react-addons/legacy/react-addons-0.11.d.ts
new file mode 100644
index 000000000..a741d545f
--- /dev/null
+++ b/react-addons/legacy/react-addons-0.11.d.ts
@@ -0,0 +1,172 @@
+// Type definitions for React with Addons 0.11.2
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../../react/legacy/react-0.11.d.ts" />
+
+declare module "react/addons" {
+    export = React;
+}
+
+declare module React {
+    export var addons: {
+        classSet: (classes: {[key: string]: boolean}) => string;
+        cloneWithProps: CloneWithProps<any>;
+        CSSTransitionGroup: Factory<CSSTransitionGroupProps>;
+        LinkedStateMixin: LinkedStateMixin<any, any>;
+        Perf: Perf;
+        PureRenderMixin: Mixin<any, any>;
+        TestUtils: TestUtils;
+        TransitionGroup: Factory<any>;
+        update(object: Object, changes: Object): Object;
+    };
+
+    export interface CloneWithProps<P> {
+        (instance: Descriptor<P>, extraProps?: P): Descriptor<P>;
+    }
+
+    export interface ReactLink<T> {
+        value: T;
+        requestChange(newValue: T): void;
+    }
+
+    export interface LinkedStateMixin<P, S> extends Mixin<P, S> {
+        linkState<T>(key: string): ReactLink<T>;
+    }
+
+    export interface ComponentPerfContext {
+        current: string;
+        owner: string;
+    }
+
+    export interface CSSTransitionGroupProps {
+        transitionName: string;
+    }
+
+    export interface TransitionsSpecification<P, S> extends Specification<P, S> {
+        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: Descriptor<any>): Descriptor<any>;
+        mockComponent(componentClass: Factory<any>, mockTagName?: string): TestUtils;
+        isDescriptorOfType(descriptor: Descriptor<any>, componentClass: Factory<any>): boolean;
+        isDOMComponent(instance: Descriptor<any>): boolean;
+        isCompositeComponent(instance: Descriptor<any>): boolean;
+        isCompositeComponentWithType(instance: Descriptor<any>, componentClass: Function): boolean;
+        isTextComponent(instance: Descriptor<any>): boolean;
+        findAllInRenderedTree(tree: Descriptor<any>, test: Function): Descriptor<any>[];
+        scryRenderedDOMComponentsWithClass(tree: Descriptor<any>, className: string): Descriptor<any>[];
+        findRenderedDOMComponentWithClass(tree: Descriptor<any>, className: string): Descriptor<any>;
+        scryRenderedDOMComponentsWithTag(tree: Descriptor<any>, className: string): Descriptor<any>[];
+        findRenderedDOMComponentWithTag(tree: Descriptor<any>, tagName: string): Descriptor<any>;
+        scryFindRenderedComponentsWithTag(tree: Descriptor<any>, componentClass: Function): Descriptor<any>[];
+        findRenderedComponentWithType(tree: Descriptor<any>, componentClass: Function): Descriptor<any>;
+    }
+
+    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: Descriptor<any>, 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/legacy/react-0.11-tests.ts b/react/legacy/react-0.11-tests.ts
new file mode 100644
index 000000000..497f4e86f
--- /dev/null
+++ b/react/legacy/react-0.11-tests.ts
@@ -0,0 +1,107 @@
+/// <reference path="react-0.11.d.ts" />
+import React = require("react");
+
+var PropTypesSpecification: React.Specification<any, any> = {
+    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.renderable,
+
+        // 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.
+        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
+        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) {
+            if (!/matchme/.test(props[propName])) {
+                return new Error('Validation failed!');
+            }
+            return null;
+        }
+    },
+    render: (): React.Descriptor<any> => {
+        return null;
+    }
+};
+
+React.createClass(PropTypesSpecification);
+
+var mountNode: Element;
+
+var HelloMessage = React.createClass({displayName: 'HelloMessage',
+    render: function() {
+        return React.DOM.div(null, "Hello ", (<React.Component<{name: string}, any>>this).props.name);
+    }
+});
+
+React.renderComponent(HelloMessage({name: "John"}), mountNode);
+
+var Timer = React.createClass({displayName: 'Timer',
+    getInitialState: function() {
+        return {secondsElapsed: 0};
+    },
+    tick: function() {
+        (<React.Component<any, {secondsElapsed: number}>>this).setState({
+            secondsElapsed: (<React.Component<any, {secondsElapsed: number}>>this).state.secondsElapsed + 1
+        });
+    },
+    componentDidMount: function() {
+        this.interval = setInterval(this.tick, 1000);
+    },
+    componentWillUnmount: function() {
+        clearInterval(this.interval);
+    },
+    render: function() {
+        return React.DOM.div(
+            null,
+            "Seconds Elapsed: ",
+            (<React.Component<any, {secondsElapsed: number}>>this).state.secondsElapsed
+        );
+    }
+});
+
+React.renderComponent(Timer(null), mountNode);
\ No newline at end of file
diff --git a/react/legacy/react-0.11.d.ts b/react/legacy/react-0.11.d.ts
new file mode 100644
index 000000000..0b0350473
--- /dev/null
+++ b/react/legacy/react-0.11.d.ts
@@ -0,0 +1,553 @@
+// Type definitions for React 0.11.2
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "react" {
+    export = React;
+}
+
+declare module React {
+    export function createClass<P, S>(specification: Specification<P, S>): Factory<P>;
+
+    export function renderComponent<P>(component: Descriptor<P>, container: Element, callback?: () => void): Descriptor<P>;
+
+    export function unmountComponentAtNode(container: Element): boolean;
+
+    export function renderComponentToString(component: Descriptor<any>): string;
+
+    export function renderComponentToStaticMarkup(component: Descriptor<any>): string;
+
+    export function isValidClass(factory: Factory<any>): boolean;
+
+    export function isValidComponent(component: Descriptor<any>): boolean;
+
+    export function initializeTouchEvents(shouldUseTouch: boolean): void;
+
+    export interface Descriptor<P> {
+        props: P;
+    }
+
+    export interface Factory<P> {
+        (properties?: P, ...children: any[]): Descriptor<P>;
+    }
+
+    export interface Mixin<P, S> {
+        componentWillMount?(): void;
+        componentDidMount?(): void;
+        componentWillReceiveProps?(nextProps: P): void;
+        shouldComponentUpdate?(nextProps: P, nextState: S): boolean;
+        componentWillUpdate?(nextProps: P, nextState: S): void;
+        componentDidUpdate?(prevProps: P, prevState: S): void;
+        componentWillUnmount?(): void;
+    }
+
+    export interface Specification<P, S> extends Mixin<P, S> {
+        displayName?: string;
+        mixins?: Mixin<P, S>[];
+        statics?: {
+            [key: string]: Function;
+        };
+        propTypes?: ValidationMap<P>;
+        getDefaultProps?(): P;
+        getInitialState?(): S;
+        render(): Descriptor<any>;
+    }
+
+    export interface DomReferencer {
+        getDOMNode(): Element;
+    }
+
+    export interface Component<P, S> 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;
+        transferPropsTo(target: Factory<P>): Descriptor<P>;
+        setProps(nextProps: P, callback?: () => void): void;
+        replaceProps(nextProps: P, callback?: () => void): void;
+    }
+
+    export interface Constructable {
+        new(): any;
+    }
+
+    export interface Validator<P> {
+        (props: P, propName: string, componentName: string): Error;
+    }
+
+    export interface Requireable<P> extends Validator<P> {
+        isRequired: Validator<P>;
+    }
+
+    export interface ValidationMap<P> {
+        [key: string]: Validator<P>;
+    }
+
+    export var PropTypes: {
+        any: Requireable<any>;
+        array: Requireable<any>;
+        bool: Requireable<any>;
+        func: Requireable<any>;
+        number: Requireable<any>;
+        object: Requireable<any>;
+        string: Requireable<any>;
+        renderable: Requireable<any>;
+        component: Requireable<any>;
+        instanceOf: (clazz: Constructable) => Requireable<any>;
+        oneOf: (types: any[]) => Requireable<any>
+        oneOfType: (types: Validator<any>[]) => Requireable<any>;
+        arrayOf: (type: Validator<any>) => Requireable<any>;
+        objectOf: (type: Validator<any>) => Requireable<any>;
+        shape: (type: ValidationMap<any>) => Requireable<any>;
+    };
+
+    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 {
+        bubbles: boolean;
+        cancelable: boolean;
+        currentTarget: EventTarget;
+        defaultPrevented: boolean;
+        eventPhase: number;
+        nativeEvent: Event;
+        preventDefault(): void;
+        stopPropagation(): void;
+        target: EventTarget;
+        timeStamp: Date;
+        type: string;
+    }
+
+    export interface ClipboardEvent extends SyntheticEvent {
+        clipboardData: DataTransfer;
+    }
+
+    export interface KeyboardEvent extends SyntheticEvent {
+        altKey: boolean;
+        charCode: number;
+        ctrlKey: boolean;
+        getModifierState(key: string): boolean;
+        key: string;
+        keyCode: number;
+        locale: string;
+        location: number;
+        metaKey: boolean;
+        repeat: boolean;
+        shiftKey: boolean;
+        which: number;
+    }
+
+    export interface FocusEvent extends SyntheticEvent {
+        relatedTarget: EventTarget;
+    }
+
+    export interface MouseEvent extends SyntheticEvent {
+        altKey: boolean;
+        button: number;
+        buttons: number;
+        clientX: number;
+        clientY: number;
+        ctrlKey: boolean;
+        getModifierState(key: string): boolean;
+        metaKey: boolean;
+        pageX: number;
+        pageY: number;
+        relatedTarget: EventTarget;
+        screenX: number;
+        screenY: number;
+        shiftKey: boolean;
+    }
+
+    export interface TouchEvent extends SyntheticEvent {
+        altKey: boolean;
+        changedTouches: TouchList;
+        ctrlKey: boolean;
+        getModifierState(key: string): boolean;
+        metaKey: boolean;
+        shiftKey: boolean;
+        targetTouches: TouchList;
+        touches: TouchList;
+    }
+
+    export interface UiEvent extends SyntheticEvent {
+        detail: number;
+        view: AbstractView;
+    }
+
+    export 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;
+    }
+
+    export interface ReactAttributes {
+        dangerouslySetInnerHTML?: {
+            __html: string;
+        };
+        children?: any[];
+        key?: string;
+        ref?: 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;
+        controls?: any;
+        coords?: any;
+        crossOrigin?: any;
+        data?: any;
+        dateTime?: any;
+        defer?: any;
+        dir?: any;
+        disabled?: any;
+        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;
+    }
+
+    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;
+    }
+
+    export interface DomElement extends Factory<DomAttributes> {
+    }
+
+    export interface SvgElement extends Factory<SvgAttributes> {
+    }
+
+    export var DOM: {
+        // 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;
+        // 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;
+    };
+}
\ No newline at end of file

From 8336da666da1d527f072dd7a72ccbe49bfef2dd3 Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 12:14:42 -0700
Subject: [PATCH 02/10] Renaming the legacy module for tests

Apparently they conflict otherwise which is unfortunate.
---
 react-addons/legacy/react-addons-0.11-tests.ts | 2 +-
 react-addons/legacy/react-addons-0.11.d.ts     | 2 +-
 react/legacy/react-0.11-tests.ts               | 3 ++-
 react/legacy/react-0.11.d.ts                   | 2 +-
 react/react.d.ts                               | 2 +-
 5 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/react-addons/legacy/react-addons-0.11-tests.ts b/react-addons/legacy/react-addons-0.11-tests.ts
index 2c5c781d7..e34e42fbc 100644
--- a/react-addons/legacy/react-addons-0.11-tests.ts
+++ b/react-addons/legacy/react-addons-0.11-tests.ts
@@ -1,5 +1,5 @@
 /// <reference path="react-addons-0.11.d.ts" />
-import React = require("react/addons");
+import React = require("react/addons-0.11");
 
 var PropTypesSpecification: React.Specification<any, any> = {
     propTypes: {
diff --git a/react-addons/legacy/react-addons-0.11.d.ts b/react-addons/legacy/react-addons-0.11.d.ts
index a741d545f..3e2f22a51 100644
--- a/react-addons/legacy/react-addons-0.11.d.ts
+++ b/react-addons/legacy/react-addons-0.11.d.ts
@@ -5,7 +5,7 @@
 
 /// <reference path="../../react/legacy/react-0.11.d.ts" />
 
-declare module "react/addons" {
+declare module "react/addons-0.11" {
     export = React;
 }
 
diff --git a/react/legacy/react-0.11-tests.ts b/react/legacy/react-0.11-tests.ts
index 497f4e86f..83029993b 100644
--- a/react/legacy/react-0.11-tests.ts
+++ b/react/legacy/react-0.11-tests.ts
@@ -1,5 +1,5 @@
 /// <reference path="react-0.11.d.ts" />
-import React = require("react");
+import React = require("react-0.11");
 
 var PropTypesSpecification: React.Specification<any, any> = {
     propTypes: {
@@ -63,6 +63,7 @@ var PropTypesSpecification: React.Specification<any, any> = {
             return null;
         }
     },
+
     render: (): React.Descriptor<any> => {
         return null;
     }
diff --git a/react/legacy/react-0.11.d.ts b/react/legacy/react-0.11.d.ts
index 0b0350473..468dabe8b 100644
--- a/react/legacy/react-0.11.d.ts
+++ b/react/legacy/react-0.11.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Asana <https://asana.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module "react" {
+declare module "react-0.11" {
     export = React;
 }
 
diff --git a/react/react.d.ts b/react/react.d.ts
index 0b0350473..f3547a95c 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for React 0.11.2
+// Type definitions for React 0.12.RC
 // Project: http://facebook.github.io/react/
 // Definitions by: Asana <https://asana.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

From d908e8f3bf7daeb8873bd17d4eb664cd5347f2da Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 12:26:28 -0700
Subject: [PATCH 03/10] Renaming based on the new React API

http://facebook.github.io/react/blog/2014/10/16/react-v0.12-rc1.html#renamed-apis
---
 react-addons/react-addons-tests.ts |  6 +++---
 react/react-tests.ts               |  6 +++---
 react/react.d.ts                   | 10 +++++-----
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/react-addons/react-addons-tests.ts b/react-addons/react-addons-tests.ts
index cdfae1266..c7b3ffdd7 100644
--- a/react-addons/react-addons-tests.ts
+++ b/react-addons/react-addons-tests.ts
@@ -14,7 +14,7 @@ var PropTypesSpecification: React.Specification<any, any> = {
 
         // Anything that can be rendered: numbers, strings, components or an array
         // containing these types.
-        optionalRenderable: React.PropTypes.renderable,
+        optionalRenderable: React.PropTypes.node,
 
         // A React component.
         optionalComponent: React.PropTypes.component,
@@ -78,7 +78,7 @@ var HelloMessage = React.createClass({displayName: 'HelloMessage',
     }
 });
 
-React.renderComponent(HelloMessage({name: "John"}), mountNode);
+React.render(HelloMessage({name: "John"}), mountNode);
 
 var Timer = React.createClass({displayName: 'Timer',
     getInitialState: function() {
@@ -104,7 +104,7 @@ var Timer = React.createClass({displayName: 'Timer',
     }
 });
 
-React.renderComponent(Timer(null), mountNode);
+React.render(Timer(null), mountNode);
 
 // TestUtils
 var that: React.Component<any, any>;
diff --git a/react/react-tests.ts b/react/react-tests.ts
index 1267713c2..dab902f02 100644
--- a/react/react-tests.ts
+++ b/react/react-tests.ts
@@ -14,7 +14,7 @@ var PropTypesSpecification: React.Specification<any, any> = {
 
         // Anything that can be rendered: numbers, strings, components or an array
         // containing these types.
-        optionalRenderable: React.PropTypes.renderable,
+        optionalRenderable: React.PropTypes.node,
 
         // A React component.
         optionalComponent: React.PropTypes.component,
@@ -78,7 +78,7 @@ var HelloMessage = React.createClass({displayName: 'HelloMessage',
     }
 });
 
-React.renderComponent(HelloMessage({name: "John"}), mountNode);
+React.render(HelloMessage({name: "John"}), mountNode);
 
 var Timer = React.createClass({displayName: 'Timer',
     getInitialState: function() {
@@ -104,4 +104,4 @@ var Timer = React.createClass({displayName: 'Timer',
     }
 });
 
-React.renderComponent(Timer(null), mountNode);
\ No newline at end of file
+React.render(Timer(null), mountNode);
\ No newline at end of file
diff --git a/react/react.d.ts b/react/react.d.ts
index f3547a95c..11a783a47 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -10,17 +10,17 @@ declare module "react" {
 declare module React {
     export function createClass<P, S>(specification: Specification<P, S>): Factory<P>;
 
-    export function renderComponent<P>(component: Descriptor<P>, container: Element, callback?: () => void): Descriptor<P>;
+    export function render<P>(component: Descriptor<P>, container: Element, callback?: () => void): Descriptor<P>;
 
     export function unmountComponentAtNode(container: Element): boolean;
 
-    export function renderComponentToString(component: Descriptor<any>): string;
+    export function renderToString(component: Descriptor<any>): string;
 
-    export function renderComponentToStaticMarkup(component: Descriptor<any>): string;
+    export function renderToStaticMarkup(component: Descriptor<any>): string;
 
     export function isValidClass(factory: Factory<any>): boolean;
 
-    export function isValidComponent(component: Descriptor<any>): boolean;
+    export function isValidElement(component: Descriptor<any>): boolean;
 
     export function initializeTouchEvents(shouldUseTouch: boolean): void;
 
@@ -97,7 +97,7 @@ declare module React {
         number: Requireable<any>;
         object: Requireable<any>;
         string: Requireable<any>;
-        renderable: Requireable<any>;
+        node: Requireable<any>;
         component: Requireable<any>;
         instanceOf: (clazz: Constructable) => Requireable<any>;
         oneOf: (types: any[]) => Requireable<any>

From 8b6079cfcd1db0863c9ab2e9ba9ee2a31c2b3d8a Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 12:29:45 -0700
Subject: [PATCH 04/10] Removing transferPropsTo

---
 react/react.d.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/react/react.d.ts b/react/react.d.ts
index 11a783a47..eb7b4989b 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -68,7 +68,6 @@ declare module React {
         replaceState(nextState: S, callback?: () => void): void;
         forceUpdate(callback?: () => void): void;
         isMounted(): boolean;
-        transferPropsTo(target: Factory<P>): Descriptor<P>;
         setProps(nextProps: P, callback?: () => void): void;
         replaceProps(nextProps: P, callback?: () => void): void;
     }

From 51b6fad2472eb1ec752b32c4b9e9a2b896347ce3 Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 13:22:14 -0700
Subject: [PATCH 05/10] Adding the new Element types

https://gist.github.com/sebmarkbage/fcb1b6ab493b0c77d589
---
 react-addons/react-addons.d.ts |  8 ++--
 react/react.d.ts               | 86 +++++++++++++++++++++++++++-------
 2 files changed, 74 insertions(+), 20 deletions(-)

diff --git a/react-addons/react-addons.d.ts b/react-addons/react-addons.d.ts
index 09ea7257a..e4041a073 100644
--- a/react-addons/react-addons.d.ts
+++ b/react-addons/react-addons.d.ts
@@ -13,12 +13,12 @@ declare module React {
     export var addons: {
         classSet: (classes: {[key: string]: boolean}) => string;
         cloneWithProps: CloneWithProps<any>;
-        CSSTransitionGroup: Factory<CSSTransitionGroupProps>;
+        CSSTransitionGroup: ReactFactory<CSSTransitionGroupProps>;
         LinkedStateMixin: LinkedStateMixin<any, any>;
         Perf: Perf;
         PureRenderMixin: Mixin<any, any>;
         TestUtils: TestUtils;
-        TransitionGroup: Factory<any>;
+        TransitionGroup: ReactFactory<any>;
         update(object: Object, changes: Object): Object;
     };
 
@@ -80,8 +80,8 @@ declare module React {
     export interface TestUtils {
         Simulate: Simulate;
         renderIntoDocument(instance: Descriptor<any>): Descriptor<any>;
-        mockComponent(componentClass: Factory<any>, mockTagName?: string): TestUtils;
-        isDescriptorOfType(descriptor: Descriptor<any>, componentClass: Factory<any>): boolean;
+        mockComponent(componentClass: ReactFactory<any>, mockTagName?: string): TestUtils;
+        isDescriptorOfType(descriptor: Descriptor<any>, componentClass: ReactFactory<any>): boolean;
         isDOMComponent(instance: Descriptor<any>): boolean;
         isCompositeComponent(instance: Descriptor<any>): boolean;
         isCompositeComponentWithType(instance: Descriptor<any>, componentClass: Function): boolean;
diff --git a/react/react.d.ts b/react/react.d.ts
index eb7b4989b..407605944 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -4,33 +4,93 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare module "react" {
-    export = React;
+export = React;
 }
 
 declare module React {
-    export function createClass<P, S>(specification: Specification<P, S>): Factory<P>;
+    export function createClass<P, S>(specification: Specification<P, S>): ReactComponentFactory<P>;
 
-    export function render<P>(component: Descriptor<P>, container: Element, callback?: () => void): Descriptor<P>;
+    export function render<P>(component: ReactComponentElement<P>, container: Element, callback?: () => void): ReactComponentElement<P>;
+
+    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: Descriptor<any>): string;
+    export function renderToString<P>(component: ReactComponentElement<P>): string;
 
-    export function renderToStaticMarkup(component: Descriptor<any>): string;
+    export function renderToString(component: ReactHTMLElement): string;
 
-    export function isValidClass(factory: Factory<any>): boolean;
+    export function renderToString(component: ReactSVGElement): string;
 
-    export function isValidElement(component: Descriptor<any>): boolean;
+    export function renderToStaticMarkup<P>(component: ReactComponentElement<P>): string;
+
+    export function renderToStaticMarkup(component: ReactHTMLElement): string;
+
+    export function renderToStaticMarkup(component: ReactSVGElement): string;
+
+    export function isValidClass(factory: ReactComponentElement<any>): boolean;
+
+    export function isValidElement(component: ReactHTMLElement): boolean;
+
+    export function isValidElement(component: ReactSVGElement): boolean;
 
     export function initializeTouchEvents(shouldUseTouch: boolean): void;
 
+    export interface ReactFactory<P, E extends ReactElement> {
+        (properties: P, ...children: any[]): E;
+    }
+
+    export interface ReactComponentFactory<P> extends ReactFactory<P, ReactComponentElement<P>> {
+    }
+
+    export interface ReactElementFactory<P, E extends ReactDOMElement<any>> extends ReactFactory<P, E>  {
+    }
+
+    export interface DomElement extends ReactElementFactory<DomAttributes, ReactHTMLElement> {
+    }
+
+    export interface SvgElement extends ReactElementFactory<SvgAttributes, ReactSVGElement> {
+    }
+
+    export interface ReactClass<P> {
+        (props: P): ReactComponent<P>;
+    }
+
+    export interface ReactComponent<P> {
+        props: P;
+        render(): ReactElement;
+    }
+
+    export interface ReactElement {
+        type: any;
+        props: any;
+        key: string;
+        ref: string;
+    }
+
+    export interface ReactDOMElement<P> extends ReactElement {
+        type: string;
+        props: P;
+    }
+
+    export interface ReactHTMLElement extends ReactDOMElement<DomAttributes> {
+    }
+
+    export interface ReactSVGElement extends ReactDOMElement<SvgAttributes> {
+    }
+
+    export interface ReactComponentElement<P> extends ReactElement {
+        type: ReactClass<P>;
+        props: P;
+    }
+
     export interface Descriptor<P> {
         props: P;
     }
 
-    export interface Factory<P> {
-        (properties?: P, ...children: any[]): Descriptor<P>;
-    }
+
 
     export interface Mixin<P, S> {
         componentWillMount?(): void;
@@ -411,12 +471,6 @@ declare module React {
         y?: any;
     }
 
-    export interface DomElement extends Factory<DomAttributes> {
-    }
-
-    export interface SvgElement extends Factory<SvgAttributes> {
-    }
-
     export var DOM: {
         // HTML
         a: DomElement;

From d7650b9d843172e48601ed44d18eebd4ccd503ca Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 13:24:04 -0700
Subject: [PATCH 06/10] Fixing React Addons

---
 react-addons/react-addons.d.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/react-addons/react-addons.d.ts b/react-addons/react-addons.d.ts
index e4041a073..651ffe83a 100644
--- a/react-addons/react-addons.d.ts
+++ b/react-addons/react-addons.d.ts
@@ -13,12 +13,12 @@ declare module React {
     export var addons: {
         classSet: (classes: {[key: string]: boolean}) => string;
         cloneWithProps: CloneWithProps<any>;
-        CSSTransitionGroup: ReactFactory<CSSTransitionGroupProps>;
+        CSSTransitionGroup: ReactComponentFactory<CSSTransitionGroupProps>;
         LinkedStateMixin: LinkedStateMixin<any, any>;
         Perf: Perf;
         PureRenderMixin: Mixin<any, any>;
         TestUtils: TestUtils;
-        TransitionGroup: ReactFactory<any>;
+        TransitionGroup: ReactComponentFactory<any>;
         update(object: Object, changes: Object): Object;
     };
 
@@ -80,8 +80,8 @@ declare module React {
     export interface TestUtils {
         Simulate: Simulate;
         renderIntoDocument(instance: Descriptor<any>): Descriptor<any>;
-        mockComponent(componentClass: ReactFactory<any>, mockTagName?: string): TestUtils;
-        isDescriptorOfType(descriptor: Descriptor<any>, componentClass: ReactFactory<any>): boolean;
+        mockComponent(componentClass: ReactComponentFactory<any>, mockTagName?: string): TestUtils;
+        isDescriptorOfType(descriptor: Descriptor<any>, componentClass: ReactComponentFactory<any>): boolean;
         isDOMComponent(instance: Descriptor<any>): boolean;
         isCompositeComponent(instance: Descriptor<any>): boolean;
         isCompositeComponentWithType(instance: Descriptor<any>, componentClass: Function): boolean;

From f547d80f4921536474bc09b8b55bc7177e6c6010 Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 16:24:11 -0700
Subject: [PATCH 07/10] Removed descriptors from our code

---
 react-addons/react-addons-tests.ts |  2 +-
 react-addons/react-addons.d.ts     | 32 ++++++++++++++------------
 react/react-tests.ts               |  2 +-
 react/react.d.ts                   | 37 +++++++++++-------------------
 4 files changed, 33 insertions(+), 40 deletions(-)

diff --git a/react-addons/react-addons-tests.ts b/react-addons/react-addons-tests.ts
index c7b3ffdd7..4834d6e23 100644
--- a/react-addons/react-addons-tests.ts
+++ b/react-addons/react-addons-tests.ts
@@ -63,7 +63,7 @@ var PropTypesSpecification: React.Specification<any, any> = {
             return null;
         }
     },
-    render: (): React.Descriptor<any> => {
+    render: (): React.ReactHTMLElement => {
         return null;
     }
 };
diff --git a/react-addons/react-addons.d.ts b/react-addons/react-addons.d.ts
index 651ffe83a..d0787c88a 100644
--- a/react-addons/react-addons.d.ts
+++ b/react-addons/react-addons.d.ts
@@ -23,7 +23,7 @@ declare module React {
     };
 
     export interface CloneWithProps<P> {
-        (instance: Descriptor<P>, extraProps?: P): Descriptor<P>;
+        (instance: ReactComponentElement<P>, extraProps?: P): ReactComponentElement<P>;
     }
 
     export interface ReactLink<T> {
@@ -79,20 +79,22 @@ declare module React {
 
     export interface TestUtils {
         Simulate: Simulate;
-        renderIntoDocument(instance: Descriptor<any>): Descriptor<any>;
+        renderIntoDocument<P>(instance: ReactComponentElement<P>): ReactComponentElement<P>;
+        renderIntoDocument(instnace: ReactHTMLElement): ReactHTMLElement;
+        renderIntoDocument(instnace: ReactSVGElement): ReactSVGElement;
         mockComponent(componentClass: ReactComponentFactory<any>, mockTagName?: string): TestUtils;
-        isDescriptorOfType(descriptor: Descriptor<any>, componentClass: ReactComponentFactory<any>): boolean;
-        isDOMComponent(instance: Descriptor<any>): boolean;
-        isCompositeComponent(instance: Descriptor<any>): boolean;
-        isCompositeComponentWithType(instance: Descriptor<any>, componentClass: Function): boolean;
-        isTextComponent(instance: Descriptor<any>): boolean;
-        findAllInRenderedTree(tree: Descriptor<any>, test: Function): Descriptor<any>[];
-        scryRenderedDOMComponentsWithClass(tree: Descriptor<any>, className: string): Descriptor<any>[];
-        findRenderedDOMComponentWithClass(tree: Descriptor<any>, className: string): Descriptor<any>;
-        scryRenderedDOMComponentsWithTag(tree: Descriptor<any>, className: string): Descriptor<any>[];
-        findRenderedDOMComponentWithTag(tree: Descriptor<any>, tagName: string): Descriptor<any>;
-        scryFindRenderedComponentsWithTag(tree: Descriptor<any>, componentClass: Function): Descriptor<any>[];
-        findRenderedComponentWithType(tree: Descriptor<any>, componentClass: Function): Descriptor<any>;
+        isDescriptorOfType(descriptor: ReactElement<any, any>, componentClass: ReactComponentFactory<any>): boolean;
+        isDOMComponent(instance: ReactElement<any, any>): boolean;
+        isCompositeComponent(instance: ReactElement<any, any>): boolean;
+        isCompositeComponentWithType(instance: ReactElement<any, any>, componentClass: ReactComponentFactory<any>): boolean;
+        isTextComponent(instance: ReactElement<any, any>): boolean;
+        findAllInRenderedTree(tree: ReactElement<any, any>, test: (component: ReactElement<any, any>) => boolean): ReactElement<any, any>[];
+        scryRenderedDOMComponentsWithClass(tree: ReactElement<any, any>, className: string): ReactElement<any, any>[];
+        findRenderedDOMComponentWithClass(tree: ReactElement<any, any>, className: string): ReactElement<any, any>;
+        scryRenderedDOMComponentsWithTag(tree: ReactElement<any, any>, className: string): ReactElement<any, any>[];
+        findRenderedDOMComponentWithTag(tree: ReactElement<any, any>, tagName: string): ReactElement<any, any>;
+        scryFindRenderedComponentsWithTag(tree: ReactElement<any, any>, componentClass: Function): ReactElement<any, any>[];
+        findRenderedComponentWithType(tree: ReactElement<any, any>, componentClass: Function): ReactElement<any, any>;
     }
 
     export interface SyntheticEventData {
@@ -131,7 +133,7 @@ declare module React {
 
     export interface EventSimulator {
         (element: Element, eventData?: SyntheticEventData): void;
-        (descriptor: Descriptor<any>, eventData?: SyntheticEventData): void;
+        (descriptor: ReactElement<any, any>, eventData?: SyntheticEventData): void;
     }
 
     export interface Simulate {
diff --git a/react/react-tests.ts b/react/react-tests.ts
index dab902f02..f0267d907 100644
--- a/react/react-tests.ts
+++ b/react/react-tests.ts
@@ -63,7 +63,7 @@ var PropTypesSpecification: React.Specification<any, any> = {
             return null;
         }
     },
-    render: (): React.Descriptor<any> => {
+    render: (): React.ReactHTMLElement => {
         return null;
     }
 };
diff --git a/react/react.d.ts b/react/react.d.ts
index 407605944..1383a33f0 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -38,20 +38,19 @@ declare module React {
 
     export function initializeTouchEvents(shouldUseTouch: boolean): void;
 
-    export interface ReactFactory<P, E extends ReactElement> {
-        (properties: P, ...children: any[]): E;
+
+    export interface ReactComponentFactory<P> {
+        (properties: P, ...children: any[]): ReactComponentElement<P>;
     }
 
-    export interface ReactComponentFactory<P> extends ReactFactory<P, ReactComponentElement<P>> {
+    export interface ReactElementFactory<P> {
+        (properties: P, ...children: any[]): ReactDOMElement<P>;
     }
 
-    export interface ReactElementFactory<P, E extends ReactDOMElement<any>> extends ReactFactory<P, E>  {
+    export interface DomElement extends ReactElementFactory<DomAttributes> {
     }
 
-    export interface DomElement extends ReactElementFactory<DomAttributes, ReactHTMLElement> {
-    }
-
-    export interface SvgElement extends ReactElementFactory<SvgAttributes, ReactSVGElement> {
+    export interface SvgElement extends ReactElementFactory<SvgAttributes> {
     }
 
     export interface ReactClass<P> {
@@ -60,18 +59,17 @@ declare module React {
 
     export interface ReactComponent<P> {
         props: P;
-        render(): ReactElement;
+        render(): ReactElement<any, any>;
     }
 
-    export interface ReactElement {
-        type: any;
-        props: any;
+    export interface ReactElement<T, P> {
+        type: T;
+        props: P;
         key: string;
         ref: string;
     }
 
-    export interface ReactDOMElement<P> extends ReactElement {
-        type: string;
+    export interface ReactDOMElement<P> extends ReactElement<string, P> {
         props: P;
     }
 
@@ -81,17 +79,10 @@ declare module React {
     export interface ReactSVGElement extends ReactDOMElement<SvgAttributes> {
     }
 
-    export interface ReactComponentElement<P> extends ReactElement {
-        type: ReactClass<P>;
+    export interface ReactComponentElement<P> extends ReactElement<ReactClass<P>, P> {
         props: P;
     }
 
-    export interface Descriptor<P> {
-        props: P;
-    }
-
-
-
     export interface Mixin<P, S> {
         componentWillMount?(): void;
         componentDidMount?(): void;
@@ -111,7 +102,7 @@ declare module React {
         propTypes?: ValidationMap<P>;
         getDefaultProps?(): P;
         getInitialState?(): S;
-        render(): Descriptor<any>;
+        render(): ReactElement<any, any>;
     }
 
     export interface DomReferencer {

From 3bb83a20e4c1ce582d399158dd816876641be796 Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter3@users.noreply.github.com>
Date: Fri, 17 Oct 2014 16:37:14 -0700
Subject: [PATCH 08/10] Fixing the version

---
 react-addons/react-addons.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/react-addons/react-addons.d.ts b/react-addons/react-addons.d.ts
index d0787c88a..35fc5f1fb 100644
--- a/react-addons/react-addons.d.ts
+++ b/react-addons/react-addons.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for React with Addons 0.11.2
+// Type definitions for React with Addons 0.12.RC
 // Project: http://facebook.github.io/react/
 // Definitions by: Asana <https://asana.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

From 17d211f89653ba84adc2c85fa0caa009fdbdfbd5 Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 16:42:11 -0700
Subject: [PATCH 09/10] Adding createFactory

Forgot about this piece but is important for removing warnings.
---
 react/react.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/react/react.d.ts b/react/react.d.ts
index 1383a33f0..05f763a9f 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -10,6 +10,8 @@ export = React;
 declare module React {
     export function createClass<P, S>(specification: Specification<P, S>): ReactComponentFactory<P>;
 
+    export function createFactory<P>(clazz: ReactComponentFactory<P>): ReactComponentFactory<P>;
+
     export function render<P>(component: ReactComponentElement<P>, container: Element, callback?: () => void): ReactComponentElement<P>;
 
     export function render(component: ReactHTMLElement, container: Element, callback?: () => void): ReactHTMLElement;

From c4d3efb7f1605dd3949e5bd298509df5b6c7b63a Mon Sep 17 00:00:00 2001
From: Phips Peter <pspeter333@gmail.com>
Date: Fri, 17 Oct 2014 16:51:08 -0700
Subject: [PATCH 10/10] Fixing isValidClass and isValidElement

The terminology is confusing right now.
---
 react/react.d.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/react/react.d.ts b/react/react.d.ts
index 05f763a9f..2d6696066 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -32,7 +32,9 @@ declare module React {
 
     export function renderToStaticMarkup(component: ReactSVGElement): string;
 
-    export function isValidClass(factory: ReactComponentElement<any>): boolean;
+    export function isValidClass(factory: ReactComponentFactory<any>): boolean;
+
+    export function isValidElement(component: ReactComponentElement<any>): boolean;
 
     export function isValidElement(component: ReactHTMLElement): boolean;