npm uninstall -S @babel/polyfill
npm install -S core-js@3

 module.exports = {
   presets: [
     [
       '@babel/preset-env',
       {
         useBuiltIns: 'usage',
+        corejs: 3,
       },
     ],
     '@babel/preset-react',
     '@babel/preset-typescript',
   ],
   plugins: ["babel-plugin-styled-components", "@babel/plugin-syntax-dynamic-import"],
 };

npm uninstall -S @prop-types

(snip)
   overrides: [
     {
       files: ['**/*.ts', '**/*.tsx'],
       rules: {
         // Set 'no-unused-vars' to off to suppress errors on importing types.
         // (e.g. error  'FunctionComponent' is defined but never used  no-unused-vars)
         // Unused vars are checked by TypeScript compiler (at-loader) instead.
         'no-unused-vars': 'off',
+        'react/prop-types': 'off',
       },
     },
   ],
 };

(snip)
-  extends: ['airbnb', 'prettier'],
+  extends: ['airbnb', 'plugin:prettier/recommended', 'prettier/react'],
(snip)

(snip)
-  extends: ['airbnb', 'plugin:prettier/recommended', 'prettier/react'],
+  extends: ['airbnb', 'airbnb/hooks', 'plugin:prettier/recommended', 'prettier/react'],
(snip)

npm install -S @material-ui/icons @material-ui/pickers

npm install -S reselect immer normalizr

npm uninstall -S connected-react-router history

 import { combineReducers } from 'redux';
-import { connectRouter } from 'connected-react-router';
 import * as reducers from './reducers';

-const createRootReducer = (history) =>
- combineReducers({
- router: connectRouter(history),
- ...reducers,
- });
-export default createRootReducer;
-const rootReducer = combineReducers(reducers);
-export default rootReducer;
+const rootReducer = combineReducers(reducers);
+export default rootReducer;

 import { createStore, applyMiddleware } from 'redux';
 import createSagaMiddleware from 'redux-saga';
-import { createBrowserHistory } from 'history';
-import { routerMiddleware } from 'connected-react-router';
 import { logger } from 'redux-logger';
 import rootSaga from './sagas/rootSaga';
-import createRootReducer from './reducers/rootReducer';
+import rootReducer from './reducers/rootReducer';

 const sagaMiddleware = createSagaMiddleware();
-export const history = createBrowserHistory();

 export default function configureStore(initialState = {}) {
   const middlewares = [];
   if (process.env.NODE_ENV === `development`) {
     middlewares.push(logger);
   }
-  middlewares.push(routerMiddleware(history));
   middlewares.push(sagaMiddleware);

   const store = createStore(
-    createRootReducer(history),
+    rootReducer,
     initialState,
     applyMiddleware(...middlewares),
   );
   sagaMiddleware.run(rootSaga);
   return store;
 }

 import React from 'react';
 import ReactDOM from 'react-dom';
 import { Provider } from 'react-redux';
-import { ConnectedRouter } from 'connected-react-router';
 import App from './components/App';
-import configureStore, { history } from './configureStore';
+import configureStore from './configureStore';

 const store = configureStore();
 const root = document.getElementById('root');

 if (root) {
   ReactDOM.render(
     <Provider store={store}>
-      <ConnectedRouter history={history}>
-        <App />
-      </ConnectedRouter>
+      <App />
     </Provider>,
     root,
   );
 }

npm uninstall -D react-test-renderer enzyme enzyme-adapter-react-16
npm install -D @testing-library/react

npm install -D @testing-library/jest-dom @testing-library/user-event

npm install -D axios-mock-adapter jest-styled-components

 // For a detailed explanation regarding each configuration property, visit:
 // https://jestjs.io/docs/en/configuration.html

 module.exports = {
 (snip)

   // The path to a module that runs some code to configure or set up the testing framework before each test
-  // setupFilesAfterEnv: null,
+  setupFilesAfterEnv: ['<rootDir>/src/setupJestTests.ts'],

 (snip)

import '@testing-library/jest-dom/extend-expect';
import 'jest-styled-components';

npm uninstall -D awesome-typescript-loader
npm install -D ts-loader source-map-loader

 {
   "compilerOptions": {
 (snip)
   },
-  "files": ["src/index.tsx"],
-  "awesomeTypescriptLoaderOptions": {
-    "useCache": true,
-    "reportFiles": ["src/**/*.{ts,tsx}"],
-    "forceIsolatedModules": true
-  }
+  "files": ["src/index.tsx"]
 }

 const path = require('path');
-const { CheckerPlugin } = require('awesome-typescript-loader');
 const packageJson = require('./package.json');

 module.exports = {
   entry: [`./${packageJson.main}`],
   output: {
     path: path.resolve(__dirname, 'dist'),
     filename: 'bundle.js',
   },
   module: {
     rules: [
       {
         test: /\.(js|jsx)$/,
         include: [path.resolve(__dirname, 'src')],
         enforce: 'pre',
         loader: 'eslint-loader',
         options: {
           configFile: './.eslintrc.js',
           failOnError: true,
         },
       },
+      {
+        test: /\.js$/,
+        enforce: 'pre',
+        loader: 'source-map-loader',
+      },
       {
         test: /\.(js|jsx)$/,
         include: [path.resolve(__dirname, 'src')],
         enforce: 'pre',
         loader: 'stylelint-custom-processor-loader',
       },
       {
         test: /\.(js|jsx)$/,
         include: [path.resolve(__dirname, 'src')],
         loader: 'babel-loader',
       },
       {
         test: /\.(ts|tsx)$/,
         include: [path.resolve(__dirname, 'src')],
-        loader: 'awesome-typescript-loader',
+        loader: 'ts-loader',
       },
       {
         test: /\.(png|woff|woff2|eot|ttf|svg)$/,
         include: [path.resolve(__dirname, 'node_modules')],
         loader: 'file-loader',
       },
     ],
   },
   resolve: {
-    extensions: ['*', '.js', '.jsx'],
+    extensions: ['*', '.ts', '.tsx', '.js', '.jsx'],
     modules: ['node_modules'],
   },
-  plugins: [
-    new CheckerPlugin(),
-  ],
 };