Add TypeScript definitions

index.d.ts

@@ -0,0 +1,81 @@
+export interface Action {
+  type: string;
+}
+
+
+/* reducers */
+
+export type Reducer<S> = <A extends Action>(state: S, action: A) => S;
+
+export function combineReducers<S>(reducers: {[key: string]: Reducer<any>}): Reducer<S>;
+
+
+/* store */
+
+export interface Dispatch {
+  <A>(action: A): A;
+  <A, B>(action: A): B;
+}
+
+export interface Store<S> {
+  dispatch: Dispatch;
+  getState(): S;
+  subscribe(listener: () => void): () => void;
+  replaceReducer(reducer: Reducer<S>): void;
+}
+
+export interface StoreCreator {
+  <S>(reducer: Reducer<S>): Store<S>;
+  <S>(reducer: Reducer<S>, initialState: S): Store<S>;
+
+  <S>(reducer: Reducer<S>, enhancer: StoreEnhancer): Store<S>;
+  <S>(reducer: Reducer<S>, initialState: S, enhancer: StoreEnhancer): Store<S>;
+}
+
+export type StoreEnhancer = (next: StoreCreator) => StoreCreator;
+
+export const createStore: StoreCreator;
+
+
+/* middleware */
+
+export interface MiddlewareAPI<S> {
+  dispatch: Dispatch;
+  getState(): S;
+}
+
+export interface Middleware {
+  <S>(api: MiddlewareAPI<S>): (next: Dispatch) => <A, B>(action: A) => B;
+}
+
+export function applyMiddleware(...middlewares: Middleware[]): StoreEnhancer;
+
+
+/* action creators */
+
+export interface ActionCreator {
+  <O>(...args: any[]): O;
+}
+
+export function bindActionCreators<
+  T extends ActionCreator|{[key: string]: ActionCreator}
+>(actionCreators: T, dispatch: Dispatch): T;
+
+
+/* compose */
+
+// from DefinitelyTyped/compose-function
+// Hardcoded signatures for 2-4 parameters
+export function compose<A, B, C>(f1: (b: B) => C,
+                                 f2: (a: A) => B): (a: A) => C;
+export function compose<A, B, C, D>(f1: (b: C) => D,
+                                    f2: (a: B) => C,
+                                    f3: (a: A) => B): (a: A) => D;
+export function compose<A, B, C, D, E>(f1: (b: D) => E,
+                                       f2: (a: C) => D,
+                                       f3: (a: B) => C,
+                                       f4: (a: A) => B): (a: A) => E;
+
+// Minimal typing for more than 4 parameters
+export function compose<I, R>(f1: (a: any) => R,
+                              ...functions: Function[]): (a: I) => R;

package.json

@@ -4,6 +4,7 @@
   "description": "Predictable state container for JavaScript apps",
   "main": "lib/index.js",
   "jsnext:main": "es/index.js",
+  "typings": "./index.d.ts",
   "files": [
     "dist",
     "lib",
@@ -88,6 +89,7 @@
     "babel-plugin-transform-es2015-unicode-regex": "^6.3.13",
     "babel-plugin-transform-object-rest-spread": "^6.3.13",
     "babel-register": "^6.3.13",
+    "chai": "^3.5.0",
     "cross-env": "^1.0.7",
     "es3ify": "^0.2.0",
     "eslint": "^1.10.3",
@@ -99,6 +101,8 @@
     "isparta": "^4.0.0",
     "mocha": "^2.2.5",
     "rimraf": "^2.3.4",
+    "typescript": "^1.7.5",
+    "typescript-definition-tester": "0.0.3",
     "webpack": "^1.9.6"
   },
   "npmName": "redux",

test/typescript.spec.js

@@ -0,0 +1,12 @@
+import * as tt from 'typescript-definition-tester'
+
+
+describe('TypeScript definitions', () => {
+  it('should compile against index.d.ts', (done) => {
+    tt.compileDirectory(
+      __dirname + '/typescript',
+      fileName => fileName.match(/\.ts$/),
+      () => done()
+    )
+  })
+})

test/typescript/createStore.ts

@@ -0,0 +1,22 @@
+import {createStore, Action} from '../../index.d.ts'
+
+interface AddTodoAction extends Action {
+  text: string;
+}
+
+function todos(state: string[] = [], action: Action): string[] {
+  switch (action.type) {
+    case 'ADD_TODO':
+      const addTodoAction = <AddTodoAction>action;
+      return state.concat([addTodoAction.text]);
+    default:
+      return state
+  }
+}
+
+let store = createStore(todos, ['Use Redux']);
+
+store.dispatch({
+  type: 'ADD_TODO',
+  text: 'Read the docs'
+})

test/typescript/loggerMiddleware.ts

@@ -0,0 +1,35 @@
+import {
+  applyMiddleware, createStore,
+  Middleware, Dispatch
+} from "../../index.d.ts";
+
+export const loggerMiddleware: Middleware = ({getState}) => {
+  return (next: Dispatch) =>
+    (action: any) => {
+      console.log('will dispatch', action)
+
+      // Call the next dispatch method in the middleware chain.
+      let returnValue = next(action)
+
+      console.log('state after dispatch', getState())
+
+      // This will likely be the action itself, unless
+      // a middleware further in chain changed it.
+      return returnValue
+    }
+}
+
+function todos(state: any, action: any) {
+  return state;
+}
+
+let store = createStore(
+  todos,
+  ['Use Redux'],
+  applyMiddleware(loggerMiddleware)
+);
+
+store.dispatch({
+  type: 'ADD_TODO',
+  text: 'Understand the middleware'
+})

test/typescript/subscribe.ts

@@ -0,0 +1,22 @@
+import {createStore} from "../../index.d.ts";
+
+const store = createStore((state: any) => state, {
+  some: {deep: {property: 42}}
+});
+
+function select(state: any) {
+  return state.some.deep.property
+}
+
+let currentValue: number;
+function handleChange() {
+  let previousValue = currentValue;
+  currentValue = select(store.getState());
+
+  if (previousValue !== currentValue) {
+    console.log('Some deep nested property changed from', previousValue, 'to', currentValue)
+  }
+}
+
+let unsubscribe = store.subscribe(handleChange);
+handleChange();

test/typescript/thunkMiddleware.ts

@@ -0,0 +1,31 @@
+import {
+  Middleware, MiddlewareAPI,
+  applyMiddleware, createStore, Dispatch
+} from "../../index";
+
+
+type Thunk<S> = <O>(dispatch: Dispatch, getState?: () => S) => O;
+
+
+const thunkMiddleware: Middleware =
+  <S>({dispatch, getState}: MiddlewareAPI<S>) =>
+    (next: Dispatch) =>
+      <A>(action: A | Thunk<S>) =>
+        typeof action === 'function' ?
+          (<Thunk<S>>action)(dispatch, getState) :
+          next(action)
+
+
+function todos(state: any, action: any) {
+  return state;
+}
+
+let store = createStore(
+  todos,
+  ['Use Redux'],
+  applyMiddleware(thunkMiddleware)
+);
+
+store.dispatch<Thunk<any>, void>((dispatch: Dispatch) => {
+  dispatch({type: 'ADD_TODO'})
+})