TypeScript rewrite (#73)

* Update to Babel 7

This is a pre-requisite to using @babel/preset-typescript later.

This change required upgrading rollup-plugin-babel, which in turn
required upgrading Rollup.js itself. Fortunately, the upgraded
rollup-plugin-babel automatically takes care of Babel helpers
deduplication and turning off module transpilation in Babel's env
preset, so the Babel configuration could be drastically simplified.
For the same reason, we don't need rollup-plugin-replace anymore.

* Remove unused @babel/plugin-external-helpers

* Add Babel Typescript preset and port isPlainObject

* Port createAction() to TypeScript

* Port configureStore() to TypeScript

* Fix Rollup configuration

* Fix type errors in serializableStateInvariantMiddleware.test.ts

* Port createReducer() to TypeScript

* Port createSlice() to TypeScript

* Port index.js to TS and add index.d.ts

* Add some typings-tester tests

* Add "target" to tsconfig.json

It's apparently not strictly needed for Babel's TypeScript plugin,
but at least more explicit.

* Use `T extends string` instaead of `string` as action type

This allows more concrete types like `Action<'increment'>` to
be inferred by TypeScript.

* Remove unneeded extension from Rollup input path

* Remove unneeded type parameter

* Avoid a type cast in createReducer()

* Type `isPlainObject` argument as `unknown`

* Make findNonSerializableValue() typing more precise

* Remove redundant "lib" in tsconfig.json

It's implied by "target": "es2018".

* Enable "esModuleInterop" in tsconfig.json

* Update typings-tester tsconfig.json

* Fix configureStore() state type inference edge case

When passing an object as `reducer` and at the same time
`preloadedState`, TypeScript infers the store state type from the
latter although `preloadedState` is potentially just a partial state.
An additional `PS` type parameter fixes this.

* Fix configureStore() state inference without extra type

Thanks to @Dudeonyx for this hack.

* Introduce EnhancedStore type for thunk dispatch

* Update formatting commands

* Reformat, again

* Package lock random changes

* Conditionally import immutable-state-invariant middleware

* Make createReducer() return Reducer<Immutable<S>, A>

This reflects the actual runtime behavior of immer (which freezes
produced values) and fixes a type error with immer >= 1.10.3.

* Revert createReducer() type change

Things are fixed in v1.10.5.

* 0.4.0-0

* Run TypeScript compiler in `prepare`

* Configure ESLint for TypeScript

For now, we need to use the Git version of typescript-eslint-parser
because the last release only supports TypeScript 3.1. A new release
is planned for any day now, so we should be able to move to an NPM
release soon.

eslint/typescript-eslint-parser#596

As ESLint's no-unused-vars doesn't work well with TypeScript, I
enabled noUnusedLocals and noUnusedParameters on the TypeScript
side instead.

* Generate TypeScript declaration files in dist/

* Revert "Generate TypeScript declaration files in dist/"

This reverts commit e449c8a.

* Publish src/ for TypeScript typings

* 0.4.0-1

Author: denisw

.babelrc

@@ -1,18 +1,3 @@
 {
-  "presets": [
-    [
-      "env",
-      {
-        "modules": false
-      }
-    ]
-  ],
-  "env": {
-    "development": {
-      "plugins": ["external-helpers"]
-    },
-    "test": {
-      "plugins": ["transform-es2015-modules-commonjs"]
-    }
-  }
+  "presets": ["@babel/preset-env", "@babel/preset-typescript"]
 }

.eslintrc.js

@@ -1,7 +1,10 @@
 module.exports = {
   extends: 'react-app',
+  parser: 'typescript-eslint-parser',
 
   rules: {
-    'jsx-a11y/href-no-hash': 'off'
+    'jsx-a11y/href-no-hash': 'off',
+    // Taken care of by TypeScript's `noUnusedLocals` / `noUnusedParameters`
+    'no-unused-vars': 'off'
   }
 }

README.md

@@ -1,39 +1,46 @@
-# Redux Starter Kit
-
-[![build status](https://img.shields.io/travis/reduxjs/redux-starter-kit/master.svg?style=flat-square)](https://travis-ci.org/reduxjs/redux-starter-kit)
-[![npm version](https://img.shields.io/npm/v/redux-starter-kit.svg?style=flat-square)](https://www.npmjs.com/package/redux-starter-kit)
-[![npm downloads](https://img.shields.io/npm/dm/redux-starter-kit.svg?style=flat-square)](https://www.npmjs.com/package/redux-starter-kit)
-
-**A simple set of tools to make using Redux easier**
-
-`npm install redux-starter-kit`
-
-(Special thanks to Github user @shotak for donating to the package name.)
-
-### Purpose
-
-The `redux-starter-kit` package is intended to help address three common complaints about Redux:
-
-- "Configuring a Redux store is too complicated"
-- "I have to add a lot of packages to get Redux to do anything useful"
-- "Redux requires too much boilerplate code"
-
-We can't solve every use case, but in the spirit of [`create-react-app`](https://github.com/facebook/create-react-app) and [`apollo-boost`](https://dev-blog.apollodata.com/zero-config-graphql-state-management-27b1f1b3c2c3), we can try to provide some tools that abstract over the setup process and handle the most common use cases, as well as include some useful utilities that will let the user simplify their application code.
-
-This package is _not_ intended to solve every possible complaint about Redux, and is deliberately limited in scope. It does _not_ address concepts like "reusable encapsulated Redux modules", data fetching, folder or file structures, managing entity relationships in the store, and so on.
-
-### What's Included
-
-`redux-starter-kit` includes:
-
-- A `configureStore()` function with simplified configuration options. It can automatically combine your slice reducers, adds whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension.
-- A `createReducer()` utility that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the [`immer` library](https://github.com/mweststrate/immer) to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
-- A `createAction()` utility that returns an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant.
-- A `createSlice()` function that accepts a set of reducer functions, a slice name, and an initial state value, and automatically generates corresponding action creators, types, and simple selector functions.
-- An improved version of the widely used `createSelector` utility for creating memoized selector functions, which can accept string keypaths as "input selectors" (re-exported from the [`selectorator` library](https://github.com/planttheidea/selectorator)).
-
-## Documentation
-
-The `redux-starter-kit` docs are now published at **https://redux-starter-kit.js.org**.
-
-We're currently expanding and rewriting our docs content - check back soon for more updates!
+# Redux Starter Kit
+
+[![build status](https://img.shields.io/travis/reduxjs/redux-starter-kit/master.svg?style=flat-square)](https://travis-ci.org/reduxjs/redux-starter-kit)
+
+[![npm version](https://img.shields.io/npm/v/redux-starter-kit.svg?style=flat-square)](https://www.npmjs.com/package/redux-starter-kit)
+
+**A simple set of tools to make using Redux easier**
+
+`npm install redux-starter-kit`
+
+(Special thanks to Github user @shotak for dona
+
+**A simple set of tools to make using Redux easier**
+
+`npm install redux-starter-kit`
+
+(Special thanks to Github user @shotak for donating to the package name.)
+
+### Purpose
+
+The `redux-starter-kit` package is intended to help address three common complaints about Redux:
+
+- "Configuring a Redux store is too complicated"
+- "I have to add a lot of packages to get Redux to do anything useful"
+- "Redux requires too much boilerplate code"
+
+We can't solve every use case, but in the spirit of le complaint about Redux, and is deliberately limited in scope. It and _not_ address concepts like "reusable encapsulated Redux modules", data fetching, folder or file s, we can try to provide some tools that abstract over the setup process and handle the most common use cases, as well as include some useful utilities that will let the user simplify their application code.
+
+This package is _not_ intended to solve every possible complaint about Redux, and is deliberately limited in scope. It does _not_ address concepts like "reusable encapsulated Redux modules", data fetching, folder or file structures, managing entity relationships in the store, and so on.
+
+### What's Included
+
+`redux-starter-kit` includes:
+
+- A `configureStore()` function with simplified configuration options. It can automatically combine your slice reducers, adds whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension.
+- A `createReducer()` utility that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the e selector functions.
+- An improved version of the wid to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
+- A `createAction()` utility that returns an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant.
+- A `createSlice()` function that accepts a set of reducer functions, a slice name, and an initial state value, and automatically generates corresponding action creators, types, and simple selector functions.
+- An improved version of the widely used `createSelector` utility for creating memoized selector functions, which can accept string keypaths as "input selectors" (re-exported from the n for more updates!).
+
+## Documentation
+
+The `redux-starter-kit` docs are now published at **tent - check back soon for more **.
+
+We're currently expanding and rewriting our docs content - check back soon for more updates!

docs/api/createReducer.md

@@ -7,7 +7,7 @@ hide_title: true
 
 # `createReducer()`
 
-A utility that simplifies creating Redux reducer functions, by defining them as lookup tables of functions to handle each action type.  It also allows you to drastically simplify immutable update logic, by writing "mutative" code inside your reducers.
+A utility that simplifies creating Redux reducer functions, by defining them as lookup tables of functions to handle each action type. It also allows you to drastically simplify immutable update logic, by writing "mutative" code inside your reducers.
 
 Redux [reducers](https://redux.js.org/basics/reducers) are often implemented using a `switch` statement, with one `case` for every handled action type.
 
@@ -49,7 +49,7 @@ const counterReducer = createReducer(0, {
 
 ## Direct State Mutation
 
-Redux requires reducer functions to be pure and treat state values as immutable.  While this is essential for making state updates predictable and observable, it can sometimes make the implementation of such updates awkward. Consider the following example:
+Redux requires reducer functions to be pure and treat state values as immutable. While this is essential for making state updates predictable and observable, it can sometimes make the implementation of such updates awkward. Consider the following example:
 
 ```js
 const addTodo = createAction('todos/add')
@@ -72,7 +72,7 @@ const todosReducer = createReducer([], {
 })
 ```
 
-The  `addTodo` reducer is pretty easy to follow if you know the [ES6 spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax).  However, the code for  `toggleTodo` is much less straightforward, especially considering that it only sets a single flag.
+The `addTodo` reducer is pretty easy to follow if you know the [ES6 spread syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax). However, the code for `toggleTodo` is much less straightforward, especially considering that it only sets a single flag.
 
 To make things easier, `createReducer` uses [immer](https://github.com/mweststrate/immer) to let you write reducers as if they were mutating the state directly. In reality, the reducer receives a proxy state that translates all mutations into equivalent copy operations.
 
@@ -97,7 +97,7 @@ const todosReducer = createReducer([], {
 })
 ```
 
-If you choose to write reducers in this style, make sure to learn about  the [pitfalls mentioned in the immer docs](https://github.com/mweststrate/immer#pitfalls) . Most importantly, you need to ensure that you either mutate the `state` argument or return a new state, _but not both_. For example, the following reducer would throw an exception if a `toggleTodo` action is passed:
+If you choose to write reducers in this style, make sure to learn about the [pitfalls mentioned in the immer docs](https://github.com/mweststrate/immer#pitfalls) . Most importantly, you need to ensure that you either mutate the `state` argument or return a new state, _but not both_. For example, the following reducer would throw an exception if a `toggleTodo` action is passed:
 
 ```js
 const todosReducer = createReducer([], {
@@ -111,11 +111,7 @@ const todosReducer = createReducer([], {
     // ... and returns a new value. This will throw an
     // exception. In this example, the easiest fix is
     // to remove the `return` statement.
-    return [
-      ...state.slice(0, index),
-      todo,
-      ...state.slice(index + 1)
-    ]
+    return [...state.slice(0, index), todo, ...state.slice(index + 1)]
   }
 })
 ```

index.d.ts

@@ -0,0 +1,29 @@
+export { default as createNextState } from 'immer'
+export {
+  Action,
+  ActionCreator,
+  AnyAction,
+  Middleware,
+  Reducer,
+  Store,
+  StoreEnhancer
+} from 'redux'
+export { default as createSelector } from 'selectorator'
+
+export {
+  configureStore,
+  ConfigureStoreOptions,
+  getDefaultMiddleware
+} from './src/configureStore'
+export {
+  createAction,
+  getType,
+  PayloadAction,
+  PayloadActionCreator
+} from './src/createAction'
+export { createReducer } from './src/createReducer'
+export { createSlice, CreateSliceOptions, Slice } from './src/createSlice'
+export {
+  default as createSerializableStateInvariantMiddleware,
+  isPlain
+} from './src/serializableStateInvariantMiddleware'