Merge pull request #4898 from mrk21/react-router-0.13.x

Support ReactRouter 0.13.x

react-router/legacy/react-router-0.12-test.d.ts

@@ -0,0 +1,6 @@
+///<reference path='../../react/legacy/react-0.12.d.ts' />
+
+declare module 'react-0.12' {
+    var exports: React.Exports;
+    export = exports;
+}

react-router/legacy/react-router-0.12-test.ts

@@ -0,0 +1,347 @@
+///<reference path='react-router-0.12-test.d.ts' />
+///<reference path="react-router-0.12.d.ts" />
+"use strict";
+
+import React = require('react-0.12');
+import Router = ReactRouter;
+
+// Mixin
+class NavigationTest<T extends Router.Navigation> {
+    v: T;
+    
+    makePath() {
+        var v1: string = this.v.makePath('to');
+        var v2: string = this.v.makePath('to', {id: 1});
+        var v3: string = this.v.makePath('to', {id: 1}, {type: 'json'});
+    }
+    makeHref() {
+        var v1: string = this.v.makeHref('to');
+        var v2: string = this.v.makeHref('to', {id: 1});
+        var v3: string = this.v.makeHref('to', {id: 1}, {type: 'json'});
+    }
+    transitionTo() {
+        var v1: void = this.v.transitionTo('to');
+        var v2: void = this.v.transitionTo('to', {id: 1});
+        var v3: void = this.v.transitionTo('to', {id: 1}, {type: 'json'});
+    }
+    replaceWith() {
+        var v1: void = this.v.replaceWith('to');
+        var v2: void = this.v.replaceWith('to', {id: 1});
+        var v3: void = this.v.replaceWith('to', {id: 1}, {type: 'json'});
+    }
+    goBack() {
+        var v1: void = this.v.goBack();
+    }
+}
+
+class StateTest<T extends Router.State> {
+    v: T;
+    
+    getPath() {
+        var v1: string = this.v.getPath();
+    }
+    
+    getRoutes() {
+        var v1: Router.Route[] = this.v.getRoutes();
+    }
+    
+    getPathname() {
+        var v1: string = this.v.getPathname();
+    }
+    
+    getParams() {
+        var v1: {} = this.v.getParams();
+    }
+    
+    getQuery() {
+        var v1: {} = this.v.getQuery();
+    }
+    
+    isActive() {
+        var v1: boolean = this.v.isActive('to');
+        var v2: boolean = this.v.isActive('to', {id: 1});
+        var v3: boolean = this.v.isActive('to', {id: 1}, {type: 'json'});
+    }
+}
+
+class RouteHandlerMixinTest<T extends Router.RouteHandlerMixin> {
+    v: T;
+    
+    getRouteDepth() {
+        var v1: number = this.v.getRouteDepth();
+    }
+    
+    createChildRouteHandler() {
+        var v1: Router.RouteHandler = this.v.createChildRouteHandler({ref: 'hoge'});
+    }
+}
+
+
+// Location
+class LocationTest<T extends Router.LocationBase> {
+    v: T;
+    
+    push() {
+        var v1: void = this.v.push('path/to/hoge');
+    }
+    
+    replace() {
+        var v1: void = this.v.replace('path/to/hoge');
+    }
+    
+    pop() {
+        var v1: void = this.v.pop();
+    }
+    
+    getCurrentPath() {
+        var v1: void = this.v.getCurrentPath();
+    }
+}
+new LocationTest<Router.HashLocation>();
+new LocationTest<Router.HistoryLocation>();
+new LocationTest<Router.RefreshLocation>();
+
+class LocationListenerTest<T extends Router.LocationListener> {
+    v: T;
+    
+    addChangeListener() {
+        var v1: void = this.v.addChangeListener(() => console.log(1));
+    }
+    
+    removeChangeListener() {
+        var v1: void = this.v.removeChangeListener(() => console.log(1));
+    }
+}
+new LocationListenerTest<Router.HashLocation>();
+new LocationListenerTest<Router.HistoryLocation>();
+
+
+// Behavior
+class ScrollBehaviorTest<T extends Router.ScrollBehaviorBase> {
+    v: T;
+    
+    updateScrollPosition() {
+        var v1: void = this.v.updateScrollPosition({x: 33, y: 102}, 'scrollTop');
+    }
+}
+new ScrollBehaviorTest<Router.ImitateBrowserBehavior>();
+new ScrollBehaviorTest<Router.ScrollToTopBehavior>();
+
+
+// Component
+class DefaultRouteTest {
+    v: Router.DefaultRoute;
+    
+    props() {
+        var name: string = this.v.props.name;
+        var handler: React.ComponentClass<any> = this.v.props.handler;
+    }
+    
+    createElement() {
+        var Handler: React.ComponentClass<any>;
+        React.createElement(Router.DefaultRoute, null);
+        React.createElement(Router.DefaultRoute, {name: 'name', handler: Handler});
+    }
+}
+
+class LinkTest {
+    v: Router.Link;
+    
+    constructor() {
+        new NavigationTest<Router.Link>();
+        new StateTest<Router.Link>();
+    }
+    
+    props() {
+        var activeClassName: string = this.v.props.activeClassName;
+        var to: string = this.v.props.to;
+        var params: {} = this.v.props.params;
+        var query: {} = this.v.props.query;
+        var onClick: Function = this.v.props.onClick;
+    }
+    
+    getHref() {
+        var v1: string = this.v.getHref();
+    }
+    
+    getClassName() {
+        var v1: string = this.v.getClassName();
+    }
+    
+    createElement() {
+        React.createElement(Router.Link, null);
+        React.createElement(Router.Link, {to: 'home'});
+        React.createElement(Router.Link, {
+            activeClassName: 'name',
+            to: 'home',
+            params: {},
+            query: {},
+            onClick: () => console.log(1)
+        });
+    }
+}
+
+class NotFoundRouteTest {
+    v: Router.NotFoundRoute;
+    
+    props() {
+        var name: string = this.v.props.name;
+        var handler: React.ComponentClass<any> = this.v.props.handler;
+    }
+    
+    createElement() {
+        var Handler: React.ComponentClass<any>;
+        React.createElement(Router.NotFoundRoute, null);
+        React.createElement(Router.NotFoundRoute, {handler: Handler});
+        React.createElement(Router.NotFoundRoute, {handler: Handler, name: "home"});
+    }
+}
+
+class RedirectTest {
+    v: Router.Redirect;
+    
+    props() {
+        var path: string = this.v.props.path;
+        var from: string = this.v.props.from;
+        var to: string = this.v.props.to;
+    }
+    
+    createElement() {
+        React.createElement(Router.Redirect, null);
+        React.createElement(Router.Redirect, {});
+        React.createElement(Router.Redirect, {path: 'a', from: 'a', to: 'b'});
+    }
+}
+
+class RouteTest {
+    v: Router.Route;
+    
+    props() {
+        var name: string = this.v.props.name;
+        var path: string = this.v.props.path;
+        var handler: React.ComponentClass<any> = this.v.props.handler;
+        var ignoreScrollBehavior: boolean = this.v.props.ignoreScrollBehavior;
+    }
+    
+    createElement() {
+        var Handler: React.ComponentClass<any>;
+        React.createElement(Router.Route, null);
+        React.createElement(Router.Route, {});
+        React.createElement(Router.Route, {name: "home", path: "/", handler: Handler, ignoreScrollBehavior: true});
+    }
+}
+
+class RouteHandlerTest {
+    v: Router.RouteHandler;
+    
+    constructor() {
+        new RouteHandlerMixinTest<Router.RouteHandler>();
+    }
+    
+    createElement() {
+        React.createElement(Router.RouteHandler, null);
+        React.createElement(Router.RouteHandler, {});
+    }
+}
+
+
+// History
+class HistoryTest {
+    v: Router.History;
+    
+    length() {
+        var v1: number = this.v.length;
+    }
+    
+    back() {
+        var v1: void = this.v.back();
+    }
+}
+
+
+// Router
+class CreateTest {
+    v: Router.Router;
+    
+    constructor() {
+        // React.createElement() version
+        this.v = Router.create({
+            routes: React.createElement(Router.Route, null)
+        });
+        this.v = Router.create({
+            routes: React.createElement(Router.Route, null),
+            location: Router.HistoryLocation,
+            scrollBehavior: Router.ImitateBrowserBehavior
+        });
+        
+        // React.createFactory() version
+        this.v = Router.create({
+            routes: React.createFactory(Router.Route)()
+        });
+        this.v = Router.create({
+            routes: React.createFactory(Router.Route)(),
+            location: Router.HistoryLocation,
+            scrollBehavior: Router.ImitateBrowserBehavior
+        });
+    }
+    
+    run() {
+        this.v.run((Handler) => console.log(Handler));
+        this.v.run((Handler, state) => console.log(Handler, state));
+    }
+}
+
+class RunTest {
+    constructor() {
+        // React.createElement() version
+        var v1: Router.Router = Router.run(React.createElement(Router.Route, null), (Handler) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+        var v2: Router.Router = Router.run(React.createElement(Router.Route, null), Router.HistoryLocation, (Handler, state) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+        
+        // React.createFactory() version
+        var v3: Router.Router = Router.run(React.createFactory(Router.Route)(), (Handler) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+        var v4: Router.Router = Router.run(React.createFactory(Router.Route)(), Router.HistoryLocation, (Handler, state) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+    }
+}
+
+
+// Transition
+class TransitionTest {
+    constructor() {
+        var v1: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition, params, query, callback) => {
+                transition.abort();
+                transition.redirect('to');
+                transition.redirect('to', {id: 1});
+                transition.redirect('to', {id: 1}, {type: 'json'});
+                transition.retry();
+            },
+            willTransitionFrom: (transition, component, callback) => {}
+        };
+        var v2: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition, params, query) => {},
+            willTransitionFrom: (transition, component) => {}
+        };
+        var v3: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition, params) => {},
+            willTransitionFrom: (transition) => {}
+        };
+        var v4: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition) => {},
+            willTransitionFrom: () => {}
+        };
+        var v5: Router.TransitionStaticLifecycle = {
+            willTransitionTo: () => {}
+        };
+        var v6: Router.TransitionStaticLifecycle = {
+            willTransitionFrom: () => {}
+        };
+    }
+}

react-router/legacy/react-router-0.12.d.ts

@@ -0,0 +1,277 @@
+// Type definitions for React Router 0.12.0
+// Project: https://github.com/rackt/react-router
+// Definitions by: Yuichi Murata <https://github.com/mrk21>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path='../../react/legacy/react-0.12.d.ts' />
+
+declare module ReactRouter {
+    //
+    // Mixin
+    // ----------------------------------------------------------------------
+    interface Navigation {
+        makePath(to: string, params?: {}, query?: {}): string;
+        makeHref(to: string, params?: {}, query?: {}): string;
+        transitionTo(to: string, params?: {}, query?: {}): void;
+        replaceWith(to: string, params?: {}, query?: {}): void;
+        goBack(): void;
+    }
+    
+    interface RouteHandlerMixin {
+        getRouteDepth(): number;
+        createChildRouteHandler(props: {}): RouteHandler;
+    }
+    
+    interface State {
+        getPath(): string;
+        getRoutes(): Route[];
+        getPathname(): string;
+        getParams(): {};
+        getQuery(): {};
+        isActive(to: string, params?: {}, query?: {}): boolean;
+    }
+    
+    var Navigation: Navigation;
+    var State: State;
+    var RouteHandlerMixin: RouteHandlerMixin;
+    
+    
+    //
+    // Component
+    // ----------------------------------------------------------------------
+    // DefaultRoute
+    interface DefaultRouteProp {
+        name?: string;
+        handler: React.ComponentClass<any>;
+    }
+    interface DefaultRoute extends React.ReactElement<DefaultRouteProp> {
+        __react_router_default_route__: any; // dummy
+    }
+    interface DefaultRouteClass extends React.ComponentClass<DefaultRouteProp> {
+        __react_router_default_route__: any; // dummy
+    }
+    
+    // Link
+    interface LinkProp {
+        activeClassName?: string;
+        to: string;
+        params?: {};
+        query?: {};
+        onClick?: Function;
+    }
+    interface Link extends React.ReactElement<LinkProp>, Navigation, State {
+        __react_router_link__: any; // dummy
+        
+        getHref(): string;
+        getClassName(): string;
+    }
+    interface LinkClass extends React.ComponentClass<LinkProp> {
+        __react_router_link__: any; // dummy
+    }
+    
+    // NotFoundRoute
+    interface NotFoundRouteProp {
+        name?: string;
+        handler: React.ComponentClass<any>;
+    }
+    interface NotFoundRoute extends React.ReactElement<NotFoundRouteProp> {
+        __react_router_not_found_route__: any; // dummy
+    }
+    interface NotFoundRouteClass extends React.ComponentClass<NotFoundRouteProp> {
+        __react_router_not_found_route__: any; // dummy
+    }
+    
+    // Redirect
+    interface RedirectProp {
+        path?: string;
+        from?: string;
+        to?: string;
+    }
+    interface Redirect extends React.ReactElement<RedirectProp> {
+        __react_router_redirect__: any; // dummy
+    }
+    interface RedirectClass extends React.ComponentClass<RedirectProp> {
+        __react_router_redirect__: any; // dummy
+    }
+    
+    // Route
+    interface RouteProp {
+        name?: string;
+        path?: string;
+        handler?: React.ComponentClass<any>;
+        ignoreScrollBehavior?: boolean;
+    }
+    interface Route extends React.ReactElement<RouteProp> {
+        __react_router_route__: any; // dummy
+    }
+    interface RouteClass extends React.ComponentClass<RouteProp> {
+        __react_router_route__: any; // dummy
+    }
+    
+    // RouteHandler
+    interface RouteHandlerProp {}
+    interface RouteHandler extends React.ReactElement<RouteHandlerProp>, RouteHandlerMixin {
+        __react_router_route_handler__: any; // dummy
+    }
+    interface RouteHandlerClass extends React.ReactElement<RouteHandlerProp> {
+        __react_router_route_handler__: any; // dummy
+    }
+    
+    var DefaultRoute: DefaultRouteClass;
+    var Link: LinkClass;
+    var NotFoundRoute: NotFoundRouteClass;
+    var Redirect: RedirectClass;
+    var Route: RouteClass;
+    var RouteHandler: RouteHandlerClass;
+    
+    
+    //
+    // Location
+    // ----------------------------------------------------------------------
+    interface LocationBase {
+        push(path: string): void;
+        replace(path: string): void;
+        pop(): void;
+        getCurrentPath(): void;
+    }
+    
+    interface LocationListener {
+        addChangeListener(listener: Function): void;
+        removeChangeListener(listener: Function): void;
+    }
+    
+    interface HashLocation extends LocationBase, LocationListener {}
+    interface HistoryLocation extends LocationBase, LocationListener {}
+    interface RefreshLocation extends LocationBase {}
+    
+    var HashLocation: HashLocation;
+    var HistoryLocation: HistoryLocation;
+    var RefreshLocation: RefreshLocation;
+    
+    
+    //
+    // Behavior
+    // ----------------------------------------------------------------------
+    interface ScrollBehaviorBase {
+        updateScrollPosition(position: {x: number; y: number;}, actionType: string): void;
+    }
+    interface ImitateBrowserBehavior extends ScrollBehaviorBase {}
+    interface ScrollToTopBehavior extends ScrollBehaviorBase {}
+    
+    var ImitateBrowserBehavior: ImitateBrowserBehavior;
+    var ScrollToTopBehavior: ScrollToTopBehavior;
+    
+    
+    //
+    // Router
+    // ----------------------------------------------------------------------
+    interface Router extends React.ReactElement<any> {
+        run(callback: RouterRunCallback): void;
+    }
+    
+    interface RouterState {
+        path: string;
+        action: string;
+        pathname: string;
+        params: {};
+        query: {};
+        routes : Route[];
+    }
+    
+    interface RouterCreateOption {
+        routes: React.ReactElement<RouteProp>;
+        location?: LocationBase;
+        scrollBehavior?: ScrollBehaviorBase;
+    }
+    
+    type RouterRunCallback = (Handler: Router, state: RouterState) => void;
+    
+    function create(options: RouterCreateOption): Router;
+    function run(routes: React.ReactElement<RouteProp>, callback: RouterRunCallback): Router;
+    function run(routes: React.ReactElement<RouteProp>, location: LocationBase, callback: RouterRunCallback): Router;
+    
+    
+    //
+    // History
+    // ----------------------------------------------------------------------
+    interface History {
+        back(): void;
+        length: number;
+    }
+    var History: History;
+    
+    
+    //
+    // Transition
+    // ----------------------------------------------------------------------
+    interface Transition {
+        abort(): void;
+        redirect(to: string, params?: {}, query?: {}): void;
+        retry(): void;
+    }
+    
+    interface TransitionStaticLifecycle {
+        willTransitionTo?(
+            transition: Transition,
+            params: {},
+            query: {},
+            callback: Function
+        ): void;
+        
+        willTransitionFrom?(
+            transition: Transition,
+            component: React.ReactElement<any>,
+            callback: Function
+        ): void;
+    }
+}
+
+declare module 'react-router' {
+    export = ReactRouter;
+}
+
+declare module React {
+    interface TopLevelAPI {
+        // for DefaultRoute
+        createElement(
+            type: ReactRouter.DefaultRouteClass,
+            props: ReactRouter.DefaultRouteProp,
+            ...children: ReactNode[]
+        ): ReactRouter.DefaultRoute;
+        
+        // for Link
+        createElement(
+            type: ReactRouter.LinkClass,
+            props: ReactRouter.LinkProp,
+            ...children: ReactNode[]
+        ): ReactRouter.Link;
+        
+        // for NotFoundRoute
+        createElement(
+            type: ReactRouter.NotFoundRouteClass,
+            props: ReactRouter.NotFoundRouteProp,
+            ...children: ReactNode[]
+        ): ReactRouter.NotFoundRoute;
+        
+        // for Redirect
+        createElement(
+            type: ReactRouter.RedirectClass,
+            props: ReactRouter.RedirectProp,
+            ...children: ReactNode[]
+        ): ReactRouter.Redirect;
+        
+        // for Route
+        createElement(
+            type: ReactRouter.RouteClass,
+            props: ReactRouter.RouteProp,
+            ...children: ReactNode[]
+        ): ReactRouter.Route;
+        
+        // for RouteHandler
+        createElement(
+            type: ReactRouter.RouteHandlerClass,
+            props: ReactRouter.RouteHandlerProp,
+            ...children: ReactNode[]
+        ): ReactRouter.RouteHandler;
+    }
+}

react-router/react-router-test.ts

@@ -2,12 +2,13 @@
 "use strict";
 
 import React = require('react');
+import ReactAddons = require('react/addons');
 import Router = require('react-router');
 
 // Mixin
 class NavigationTest<T extends Router.Navigation> {
     v: T;
-    
+
     makePath() {
         var v1: string = this.v.makePath('to');
         var v2: string = this.v.makePath('to', {id: 1});
@@ -35,27 +36,27 @@ class NavigationTest<T extends Router.Navigation> {
 
 class StateTest<T extends Router.State> {
     v: T;
-    
+
     getPath() {
         var v1: string = this.v.getPath();
     }
-    
+
     getRoutes() {
         var v1: Router.Route[] = this.v.getRoutes();
     }
-    
+
     getPathname() {
         var v1: string = this.v.getPathname();
     }
-    
+
     getParams() {
         var v1: {} = this.v.getParams();
     }
-    
+
     getQuery() {
         var v1: {} = this.v.getQuery();
     }
-    
+
     isActive() {
         var v1: boolean = this.v.isActive('to');
         var v2: boolean = this.v.isActive('to', {id: 1});
@@ -63,35 +64,23 @@ class StateTest<T extends Router.State> {
     }
 }
 
-class RouteHandlerMixinTest<T extends Router.RouteHandlerMixin> {
-    v: T;
-    
-    getRouteDepth() {
-        var v1: number = this.v.getRouteDepth();
-    }
-    
-    createChildRouteHandler() {
-        var v1: Router.RouteHandler = this.v.createChildRouteHandler({ref: 'hoge'});
-    }
-}
-
 
 // Location
-class LocationTest<T extends Router.LocationBase> {
+class LocationTest<T extends Router.Location> {
     v: T;
-    
+
     push() {
         var v1: void = this.v.push('path/to/hoge');
     }
-    
+
     replace() {
         var v1: void = this.v.replace('path/to/hoge');
     }
-    
+
     pop() {
         var v1: void = this.v.pop();
     }
-    
+
     getCurrentPath() {
         var v1: void = this.v.getCurrentPath();
     }
@@ -102,11 +91,11 @@ new LocationTest<Router.RefreshLocation>();
 
 class LocationListenerTest<T extends Router.LocationListener> {
     v: T;
-    
+
     addChangeListener() {
         var v1: void = this.v.addChangeListener(() => console.log(1));
     }
-    
+
     removeChangeListener() {
         var v1: void = this.v.removeChangeListener(() => console.log(1));
     }
@@ -118,7 +107,7 @@ new LocationListenerTest<Router.HistoryLocation>();
 // Behavior
 class ScrollBehaviorTest<T extends Router.ScrollBehaviorBase> {
     v: T;
-    
+
     updateScrollPosition() {
         var v1: void = this.v.updateScrollPosition({x: 33, y: 102}, 'scrollTop');
     }
@@ -130,27 +119,30 @@ new ScrollBehaviorTest<Router.ScrollToTopBehavior>();
 // Component
 class DefaultRouteTest {
     v: Router.DefaultRoute;
-    
+
     props() {
         var name: string = this.v.props.name;
         var handler: React.ComponentClass<any> = this.v.props.handler;
     }
-    
+
     createElement() {
         var Handler: React.ComponentClass<any>;
         React.createElement(Router.DefaultRoute, null);
         React.createElement(Router.DefaultRoute, {name: 'name', handler: Handler});
+        
+        ReactAddons.createElement(Router.DefaultRoute, null);
+        ReactAddons.createElement(Router.DefaultRoute, {name: 'name', handler: Handler});
     }
 }
 
 class LinkTest {
     v: Router.Link;
-    
+
     constructor() {
         new NavigationTest<Router.Link>();
         new StateTest<Router.Link>();
     }
-    
+
     props() {
         var activeClassName: string = this.v.props.activeClassName;
         var to: string = this.v.props.to;
@@ -158,15 +150,15 @@ class LinkTest {
         var query: {} = this.v.props.query;
         var onClick: Function = this.v.props.onClick;
     }
-    
+
     getHref() {
         var v1: string = this.v.getHref();
     }
-    
+
     getClassName() {
         var v1: string = this.v.getClassName();
     }
-    
+
     createElement() {
         React.createElement(Router.Link, null);
         React.createElement(Router.Link, {to: 'home'});
@@ -177,69 +169,90 @@ class LinkTest {
             query: {},
             onClick: () => console.log(1)
         });
+        
+        ReactAddons.createElement(Router.Link, null);
+        ReactAddons.createElement(Router.Link, {to: 'home'});
+        ReactAddons.createElement(Router.Link, {
+            activeClassName: 'name',
+            to: 'home',
+            params: {},
+            query: {},
+            onClick: () => console.log(1)
+        });
     }
 }
 
 class NotFoundRouteTest {
     v: Router.NotFoundRoute;
-    
+
     props() {
         var name: string = this.v.props.name;
         var handler: React.ComponentClass<any> = this.v.props.handler;
     }
-    
+
     createElement() {
         var Handler: React.ComponentClass<any>;
         React.createElement(Router.NotFoundRoute, null);
         React.createElement(Router.NotFoundRoute, {handler: Handler});
         React.createElement(Router.NotFoundRoute, {handler: Handler, name: "home"});
+        
+        ReactAddons.createElement(Router.NotFoundRoute, null);
+        ReactAddons.createElement(Router.NotFoundRoute, {handler: Handler});
+        ReactAddons.createElement(Router.NotFoundRoute, {handler: Handler, name: "home"});
     }
 }
 
 class RedirectTest {
     v: Router.Redirect;
-    
+
     props() {
         var path: string = this.v.props.path;
         var from: string = this.v.props.from;
         var to: string = this.v.props.to;
     }
-    
+
     createElement() {
         React.createElement(Router.Redirect, null);
         React.createElement(Router.Redirect, {});
         React.createElement(Router.Redirect, {path: 'a', from: 'a', to: 'b'});
+        
+        ReactAddons.createElement(Router.Redirect, null);
+        ReactAddons.createElement(Router.Redirect, {});
+        ReactAddons.createElement(Router.Redirect, {path: 'a', from: 'a', to: 'b'});
     }
 }
 
 class RouteTest {
     v: Router.Route;
-    
+
     props() {
         var name: string = this.v.props.name;
         var path: string = this.v.props.path;
         var handler: React.ComponentClass<any> = this.v.props.handler;
         var ignoreScrollBehavior: boolean = this.v.props.ignoreScrollBehavior;
     }
-    
+
     createElement() {
         var Handler: React.ComponentClass<any>;
         React.createElement(Router.Route, null);
         React.createElement(Router.Route, {});
         React.createElement(Router.Route, {name: "home", path: "/", handler: Handler, ignoreScrollBehavior: true});
+        
+        ReactAddons.createElement(Router.Route, null);
+        ReactAddons.createElement(Router.Route, {});
+        ReactAddons.createElement(Router.Route, {name: "home", path: "/", handler: Handler, ignoreScrollBehavior: true});
     }
 }
 
 class RouteHandlerTest {
     v: Router.RouteHandler;
-    
-    constructor() {
-        new RouteHandlerMixinTest<Router.RouteHandler>();
-    }
-    
+
     createElement() {
         React.createElement(Router.RouteHandler, null);
         React.createElement(Router.RouteHandler, {});
+        
+        ReactAddons.createElement(Router.RouteHandler, null);
+        ReactAddons.createElement(Router.RouteHandler, {});
     }
 }
 
@@ -247,11 +260,11 @@ class RouteHandlerTest {
 // History
 class HistoryTest {
     v: Router.History;
-    
+
     length() {
         var v1: number = this.v.length;
     }
-    
+
     back() {
         var v1: void = this.v.back();
     }
@@ -261,7 +274,7 @@ class HistoryTest {
 // Router
 class CreateTest {
     v: Router.Router;
-    
+
     constructor() {
         // React.createElement() version
         this.v = Router.create({
@@ -272,7 +285,7 @@ class CreateTest {
             location: Router.HistoryLocation,
             scrollBehavior: Router.ImitateBrowserBehavior
         });
-        
+
         // React.createFactory() version
         this.v = Router.create({
             routes: React.createFactory(Router.Route)()
@@ -283,7 +296,7 @@ class CreateTest {
             scrollBehavior: Router.ImitateBrowserBehavior
         });
     }
-    
+
     run() {
         this.v.run((Handler) => console.log(Handler));
         this.v.run((Handler, state) => console.log(Handler, state));
@@ -299,7 +312,7 @@ class RunTest {
         var v2: Router.Router = Router.run(React.createElement(Router.Route, null), Router.HistoryLocation, (Handler, state) => {
             React.render(React.createElement(Handler, null), document.body);
         });
-        
+
         // React.createFactory() version
         var v3: Router.Router = Router.run(React.createFactory(Router.Route)(), (Handler) => {
             React.render(React.createElement(Handler, null), document.body);
@@ -344,3 +357,63 @@ class TransitionTest {
         };
     }
 }
+
+
+// Context
+class ContextTest {
+    v: Router.Context
+
+    makePath() {
+        var v1: string = this.v.makePath('home');
+        var v2: string = this.v.makePath('home', {p1: 1});
+        var v3: string = this.v.makePath('home', {p1: 1}, {q1: 1});
+    }
+
+    makeHref() {
+        var v1: string = this.v.makeHref('home');
+        var v2: string = this.v.makeHref('home', {p1: 1});
+        var v3: string = this.v.makeHref('home', {p1: 1}, {q1: 1});
+    }
+
+    transitionTo() {
+        var v1: void = this.v.transitionTo('home');
+        var v2: void = this.v.transitionTo('home', {p1: 1});
+        var v3: void = this.v.transitionTo('home', {p1: 1}, {q1: 1});
+    }
+
+    replaceWith() {
+        var v1: void = this.v.replaceWith('home');
+        var v2: void = this.v.replaceWith('home', {p1: 1});
+        var v3: void = this.v.replaceWith('home', {p1: 1}, {q1: 1});
+    }
+
+    goBack() {
+        var v: void = this.v.goBack();
+    }
+
+    getCurrentPath() {
+        var v: string = this.v.getCurrentPath();
+    }
+
+    getCurrentRoutes() {
+        var v: Router.Route[] = this.v.getCurrentRoutes();
+    }
+
+    getCurrentPathname() {
+        var v: string = this.v.getCurrentPathname();
+    }
+
+    getCurrentParams() {
+        var v: {} = this.v.getCurrentParams();
+    }
+
+    getCurrentQuery() {
+        var v: {} = this.v.getCurrentQuery();
+    }
+
+    isActive() {
+        var v1: boolean = this.v.isActive('home');
+        var v2: boolean = this.v.isActive('home', {p1: 1});
+        var v3: boolean = this.v.isActive('home', {p1: 1}, {q1: 1});
+    }
+}

react-router/react-router.d.ts

@@ -1,11 +1,224 @@
-// Type definitions for React Router 0.12.0
+// Type definitions for React Router 0.13.3
 // Project: https://github.com/rackt/react-router
-// Definitions by: Yuichi Murata <https://github.com/mrk21>
+// Definitions by: Yuichi Murata <https://github.com/mrk21>, Václav Ostrožlík <https://github.com/vasek17>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-///<reference path='../react/legacy/react-0.12.d.ts' />
+///<reference path='../react/react.d.ts' />
+///<reference path='../react/react-addons.d.ts' />
 
 declare module ReactRouter {
+    //
+    // Transition
+    // ----------------------------------------------------------------------
+    interface Transition {
+        path: string;
+        abortReason: any;
+        retry(): void;
+        abort(reason?: any): void;
+        redirect(to: string, params?: {}, query?: {}): void;
+        cancel(): void;
+        from: (transition: Transition, routes: Route[], components?: React.ReactElement<any>[], callback?: (error?: any) => void) => void;
+        to: (transition: Transition, routes: Route[], params?: {}, query?: {}, callback?: (error?: any) => void) => void;
+    }
+
+    interface TransitionStaticLifecycle {
+        willTransitionTo?(
+            transition: Transition,
+            params: {},
+            query: {},
+            callback: Function
+        ): void;
+
+        willTransitionFrom?(
+            transition: Transition,
+            component: React.ReactElement<any>,
+            callback: Function
+        ): void;
+    }
+
+    //
+    // Route Configuration
+    // ----------------------------------------------------------------------
+    // DefaultRoute
+    interface DefaultRouteProp {
+        name?: string;
+        handler: React.ComponentClass<any>;
+    }
+    interface DefaultRoute extends React.ReactElement<DefaultRouteProp> {}
+    interface DefaultRouteClass extends React.ComponentClass<DefaultRouteProp> {}
+
+    // NotFoundRoute
+    interface NotFoundRouteProp {
+        name?: string;
+        handler: React.ComponentClass<any>;
+    }
+    interface NotFoundRoute extends React.ReactElement<NotFoundRouteProp> {}
+    interface NotFoundRouteClass extends React.ComponentClass<NotFoundRouteProp> {}
+
+    // Redirect
+    interface RedirectProp {
+        path?: string;
+        from?: string;
+        to?: string;
+    }
+    interface Redirect extends React.ReactElement<RedirectProp> {}
+    interface RedirectClass extends React.ComponentClass<RedirectProp> {}
+
+    // Route
+    interface RouteProp {
+        name?: string;
+        path?: string;
+        handler?: React.ComponentClass<any>;
+        ignoreScrollBehavior?: boolean;
+    }
+    interface Route extends React.ReactElement<RouteProp> {}
+    interface RouteClass extends React.ComponentClass<RouteProp> {}
+
+    var DefaultRoute: DefaultRouteClass;
+    var NotFoundRoute: NotFoundRouteClass;
+    var Redirect: RedirectClass;
+    var Route: RouteClass;
+
+    interface CreateRouteOptions {
+        name?: string;
+        path?: string;
+        ignoreScrollBehavior?: boolean;
+        isDefault?: boolean;
+        isNotFound?: boolean;
+        onEnter?: (transition: Transition, params: {}, query: {}, callback: Function) => void;
+        onLeave?: (transition: Transition, wtf: any, callback: Function) => void;
+        handler?: Function;
+        parentRoute?: Route;
+    }
+
+    type CreateRouteCallback = (route: Route) => void;
+
+    function createRoute(callback: CreateRouteCallback): Route;
+    function createRoute(options: CreateRouteOptions | string, callback: CreateRouteCallback): Route;
+    function createDefaultRoute(options?: CreateRouteOptions | string): Route;
+    function createNotFoundRoute(options?: CreateRouteOptions | string): Route;
+
+    interface CreateRedirectOptions extends CreateRouteOptions {
+        path?: string;
+        from?: string;
+        to: string;
+        params?: {};
+        query?: {};
+    }
+    function createRedirect(options: CreateRedirectOptions): Redirect;
+    function createRoutesFromReactChildren(children: Route): Route[];
+
+    //
+    // Components
+    // ----------------------------------------------------------------------
+    // Link
+    interface LinkProp {
+        activeClassName?: string;
+        activeStyle?: {};
+        to: string;
+        params?: {};
+        query?: {};
+        onClick?: Function;
+    }
+    interface Link extends React.ReactElement<LinkProp>, Navigation, State {
+        handleClick(event: any): void;
+        getHref(): string;
+        getClassName(): string;
+        getActiveState(): boolean;
+    }
+    interface LinkClass extends React.ComponentClass<LinkProp> {}
+
+    // RouteHandler
+    interface RouteHandlerProp { }
+    interface RouteHandlerChildContext {
+        routeDepth: number;
+    }
+    interface RouteHandler extends React.ReactElement<RouteHandlerProp> {
+        getChildContext(): RouteHandlerChildContext;
+        getRouteDepth(): number;
+        createChildRouteHandler(props: {}): RouteHandler;
+    }
+    interface RouteHandlerClass extends React.ComponentClass<RouteHandlerProp> {}
+
+    var Link: LinkClass;
+    var RouteHandler: RouteHandlerClass;
+
+
+    //
+    // Top-Level
+    // ----------------------------------------------------------------------
+    interface Router extends React.ReactElement<any> {
+        run(callback: RouterRunCallback): void;
+    }
+
+    interface RouterState {
+        path: string;
+        action: string;
+        pathname: string;
+        params: {};
+        query: {};
+        routes: Route[];
+    }
+
+    interface RouterCreateOption {
+        routes: Route;
+        location?: LocationBase;
+        scrollBehavior?: ScrollBehaviorBase;
+        onError?: (error: any) => void;
+        onAbort?: (error: any) => void;
+    }
+
+    type RouterRunCallback = (Handler: RouteClass, state: RouterState) => void;
+
+    function create(options: RouterCreateOption): Router;
+    function run(routes: Route, callback: RouterRunCallback): Router;
+    function run(routes: Route, location: LocationBase, callback: RouterRunCallback): Router;
+
+
+    //
+    // Location
+    // ----------------------------------------------------------------------
+    interface LocationBase {
+        getCurrentPath(): void;
+        toString(): string;
+    }
+    interface Location extends LocationBase {
+        push(path: string): void;
+        replace(path: string): void;
+        pop(): void;
+    }
+
+    interface LocationListener {
+        addChangeListener(listener: Function): void;
+        removeChangeListener(listener: Function): void;
+    }
+
+    interface HashLocation extends Location, LocationListener { }
+    interface HistoryLocation extends Location, LocationListener { }
+    interface RefreshLocation extends Location { }
+    interface StaticLocation extends LocationBase { }
+    interface TestLocation extends Location, LocationListener { }
+
+    var HashLocation: HashLocation;
+    var HistoryLocation: HistoryLocation;
+    var RefreshLocation: RefreshLocation;
+    var StaticLocation: StaticLocation;
+    var TestLocation: TestLocation;
+
+
+    //
+    // Behavior
+    // ----------------------------------------------------------------------
+    interface ScrollBehaviorBase {
+        updateScrollPosition(position: { x: number; y: number; }, actionType: string): void;
+    }
+    interface ImitateBrowserBehavior extends ScrollBehaviorBase { }
+    interface ScrollToTopBehavior extends ScrollBehaviorBase { }
+
+    var ImitateBrowserBehavior: ImitateBrowserBehavior;
+    var ScrollToTopBehavior: ScrollToTopBehavior;
+
+
     //
     // Mixin
     // ----------------------------------------------------------------------
@@ -16,12 +229,7 @@ declare module ReactRouter {
         replaceWith(to: string, params?: {}, query?: {}): void;
         goBack(): void;
     }
-    
-    interface RouteHandlerMixin {
-        getRouteDepth(): number;
-        createChildRouteHandler(props: {}): RouteHandler;
-    }
-    
+
     interface State {
         getPath(): string;
         getRoutes(): Route[];
@@ -30,167 +238,11 @@ declare module ReactRouter {
         getQuery(): {};
         isActive(to: string, params?: {}, query?: {}): boolean;
     }
-    
+
     var Navigation: Navigation;
     var State: State;
-    var RouteHandlerMixin: RouteHandlerMixin;
-    
-    
-    //
-    // Component
-    // ----------------------------------------------------------------------
-    // DefaultRoute
-    interface DefaultRouteProp {
-        name?: string;
-        handler: React.ComponentClass<any>;
-    }
-    interface DefaultRoute extends React.ReactElement<DefaultRouteProp> {
-        __react_router_default_route__: any; // dummy
-    }
-    interface DefaultRouteClass extends React.ComponentClass<DefaultRouteProp> {
-        __react_router_default_route__: any; // dummy
-    }
-    
-    // Link
-    interface LinkProp {
-        activeClassName?: string;
-        to: string;
-        params?: {};
-        query?: {};
-        onClick?: Function;
-    }
-    interface Link extends React.ReactElement<LinkProp>, Navigation, State {
-        __react_router_link__: any; // dummy
-        
-        getHref(): string;
-        getClassName(): string;
-    }
-    interface LinkClass extends React.ComponentClass<LinkProp> {
-        __react_router_link__: any; // dummy
-    }
-    
-    // NotFoundRoute
-    interface NotFoundRouteProp {
-        name?: string;
-        handler: React.ComponentClass<any>;
-    }
-    interface NotFoundRoute extends React.ReactElement<NotFoundRouteProp> {
-        __react_router_not_found_route__: any; // dummy
-    }
-    interface NotFoundRouteClass extends React.ComponentClass<NotFoundRouteProp> {
-        __react_router_not_found_route__: any; // dummy
-    }
-    
-    // Redirect
-    interface RedirectProp {
-        path?: string;
-        from?: string;
-        to?: string;
-    }
-    interface Redirect extends React.ReactElement<RedirectProp> {
-        __react_router_redirect__: any; // dummy
-    }
-    interface RedirectClass extends React.ComponentClass<RedirectProp> {
-        __react_router_redirect__: any; // dummy
-    }
-    
-    // Route
-    interface RouteProp {
-        name?: string;
-        path?: string;
-        handler?: React.ComponentClass<any>;
-        ignoreScrollBehavior?: boolean;
-    }
-    interface Route extends React.ReactElement<RouteProp> {
-        __react_router_route__: any; // dummy
-    }
-    interface RouteClass extends React.ComponentClass<RouteProp> {
-        __react_router_route__: any; // dummy
-    }
-    
-    // RouteHandler
-    interface RouteHandlerProp {}
-    interface RouteHandler extends React.ReactElement<RouteHandlerProp>, RouteHandlerMixin {
-        __react_router_route_handler__: any; // dummy
-    }
-    interface RouteHandlerClass extends React.ReactElement<RouteHandlerProp> {
-        __react_router_route_handler__: any; // dummy
-    }
-    
-    var DefaultRoute: DefaultRouteClass;
-    var Link: LinkClass;
-    var NotFoundRoute: NotFoundRouteClass;
-    var Redirect: RedirectClass;
-    var Route: RouteClass;
-    var RouteHandler: RouteHandlerClass;
-    
-    
-    //
-    // Location
-    // ----------------------------------------------------------------------
-    interface LocationBase {
-        push(path: string): void;
-        replace(path: string): void;
-        pop(): void;
-        getCurrentPath(): void;
-    }
-    
-    interface LocationListener {
-        addChangeListener(listener: Function): void;
-        removeChangeListener(listener: Function): void;
-    }
-    
-    interface HashLocation extends LocationBase, LocationListener {}
-    interface HistoryLocation extends LocationBase, LocationListener {}
-    interface RefreshLocation extends LocationBase {}
-    
-    var HashLocation: HashLocation;
-    var HistoryLocation: HistoryLocation;
-    var RefreshLocation: RefreshLocation;
-    
-    
-    //
-    // Behavior
-    // ----------------------------------------------------------------------
-    interface ScrollBehaviorBase {
-        updateScrollPosition(position: {x: number; y: number;}, actionType: string): void;
-    }
-    interface ImitateBrowserBehavior extends ScrollBehaviorBase {}
-    interface ScrollToTopBehavior extends ScrollBehaviorBase {}
-    
-    var ImitateBrowserBehavior: ImitateBrowserBehavior;
-    var ScrollToTopBehavior: ScrollToTopBehavior;
-    
-    
-    //
-    // Router
-    // ----------------------------------------------------------------------
-    interface Router extends React.ReactElement<any> {
-        run(callback: RouterRunCallback): void;
-    }
-    
-    interface RouterState {
-        path: string;
-        action: string;
-        pathname: string;
-        params: {};
-        query: {};
-        routes : Route[];
-    }
-    
-    interface RouterCreateOption {
-        routes: React.ReactElement<RouteProp>;
-        location?: LocationBase;
-        scrollBehavior?: ScrollBehaviorBase;
-    }
-    
-    type RouterRunCallback = (Handler: Router, state: RouterState) => void;
-    
-    function create(options: RouterCreateOption): Router;
-    function run(routes: React.ReactElement<RouteProp>, callback: RouterRunCallback): Router;
-    function run(routes: React.ReactElement<RouteProp>, location: LocationBase, callback: RouterRunCallback): Router;
-    
-    
+
+
     //
     // History
     // ----------------------------------------------------------------------
@@ -199,80 +251,103 @@ declare module ReactRouter {
         length: number;
     }
     var History: History;
-    
-    
+
+
     //
-    // Transition
+    // Context
     // ----------------------------------------------------------------------
-    interface Transition {
-        abort(): void;
-        redirect(to: string, params?: {}, query?: {}): void;
-        retry(): void;
-    }
-    
-    interface TransitionStaticLifecycle {
-        willTransitionTo?(
-            transition: Transition,
-            params: {},
-            query: {},
-            callback: Function
-        ): void;
-        
-        willTransitionFrom?(
-            transition: Transition,
-            component: React.ReactElement<any>,
-            callback: Function
-        ): void;
+    interface Context {
+        makePath(to: string, params?: {}, query?: {}): string;
+        makeHref(to: string, params?: {}, query?: {}): string;
+        transitionTo(to: string, params?: {}, query?: {}): void;
+        replaceWith(to: string, params?: {}, query?: {}): void;
+        goBack(): void;
+
+        getCurrentPath(): string;
+        getCurrentRoutes(): Route[];
+        getCurrentPathname(): string;
+        getCurrentParams(): {};
+        getCurrentQuery(): {};
+        isActive(to: string, params?: {}, query?: {}): boolean;
     }
 }
 
-declare module 'react-router' {
-    import Export = ReactRouter;
-    export = Export;
+declare module "react-router" {
+    export = ReactRouter;
 }
 
 declare module React {
-    interface TopLevelAPI {
-        // for DefaultRoute
-        createElement(
-            type: ReactRouter.DefaultRouteClass,
-            props: ReactRouter.DefaultRouteProp,
-            ...children: ReactNode[]
-        ): ReactRouter.DefaultRoute;
-        
-        // for Link
-        createElement(
-            type: ReactRouter.LinkClass,
-            props: ReactRouter.LinkProp,
-            ...children: ReactNode[]
-        ): ReactRouter.Link;
-        
-        // for NotFoundRoute
-        createElement(
-            type: ReactRouter.NotFoundRouteClass,
-            props: ReactRouter.NotFoundRouteProp,
-            ...children: ReactNode[]
-        ): ReactRouter.NotFoundRoute;
-        
-        // for Redirect
-        createElement(
-            type: ReactRouter.RedirectClass,
-            props: ReactRouter.RedirectProp,
-            ...children: ReactNode[]
-        ): ReactRouter.Redirect;
-        
-        // for Route
-        createElement(
-            type: ReactRouter.RouteClass,
-            props: ReactRouter.RouteProp,
-            ...children: ReactNode[]
-        ): ReactRouter.Route;
-        
-        // for RouteHandler
-        createElement(
-            type: ReactRouter.RouteHandlerClass,
-            props: ReactRouter.RouteHandlerProp,
-            ...children: ReactNode[]
-        ): ReactRouter.RouteHandler;
-    }
+  // for DefaultRoute
+  function createElement(
+    type: ReactRouter.DefaultRouteClass,
+    props: ReactRouter.DefaultRouteProp,
+    ...children: React.ReactNode[]): ReactRouter.DefaultRoute;
+
+  // for Link
+  function createElement(
+    type: ReactRouter.LinkClass,
+    props: ReactRouter.LinkProp,
+    ...children: React.ReactNode[]): ReactRouter.Link;
+
+  // for NotFoundRoute
+  function createElement(
+    type: ReactRouter.NotFoundRouteClass,
+    props: ReactRouter.NotFoundRouteProp,
+    ...children: React.ReactNode[]): ReactRouter.NotFoundRoute;
+
+  // for Redirect
+  function createElement(
+    type: ReactRouter.RedirectClass,
+    props: ReactRouter.RedirectProp,
+    ...children: React.ReactNode[]): ReactRouter.Redirect;
+
+  // for Route
+  function createElement(
+    type: ReactRouter.RouteClass,
+    props: ReactRouter.RouteProp,
+    ...children: React.ReactNode[]): ReactRouter.Route;
+
+  // for RouteHandler
+  function createElement(
+    type: ReactRouter.RouteHandlerClass,
+    props: ReactRouter.RouteHandlerProp,
+    ...children: React.ReactNode[]): ReactRouter.RouteHandler;
+}
+
+declare module "react/addons" {
+  // for DefaultRoute
+  function createElement(
+    type: ReactRouter.DefaultRouteClass,
+    props: ReactRouter.DefaultRouteProp,
+    ...children: React.ReactNode[]): ReactRouter.DefaultRoute;
+
+  // for Link
+  function createElement(
+    type: ReactRouter.LinkClass,
+    props: ReactRouter.LinkProp,
+    ...children: React.ReactNode[]): ReactRouter.Link;
+
+  // for NotFoundRoute
+  function createElement(
+    type: ReactRouter.NotFoundRouteClass,
+    props: ReactRouter.NotFoundRouteProp,
+    ...children: React.ReactNode[]): ReactRouter.NotFoundRoute;
+
+  // for Redirect
+  function createElement(
+    type: ReactRouter.RedirectClass,
+    props: ReactRouter.RedirectProp,
+    ...children: React.ReactNode[]): ReactRouter.Redirect;
+
+  // for Route
+  function createElement(
+    type: ReactRouter.RouteClass,
+    props: ReactRouter.RouteProp,
+    ...children: React.ReactNode[]): ReactRouter.Route;
+
+  // for RouteHandler
+  function createElement(
+    type: ReactRouter.RouteHandlerClass,
+    props: ReactRouter.RouteHandlerProp,
+    ...children: React.ReactNode[]): ReactRouter.RouteHandler;
 }