Building an interactive map for the Tuckerman Inferno race.
Debris from before below...
React Redux Starter Kit
After installing npm dependencies, open
.eslintrc, change the
always, and then run
npm run lint:fix-- Easy as that! Alternatively, use the same npm script after installing and extending your preferred ESLint configuration; it's easy to customize the project's code style to suit your team's needs. See, we can coexist peacefully.
This starter kit is designed to get you up and running with a bunch of awesome new front-end technologies, all on top of a configurable, feature-rich webpack build system that's already setup to provide hot reloading, CSS modules with Sass support, unit testing, code coverage reports, bundle splitting, and a whole lot more.
The primary goal of this project is to remain as unopinionated as possible. Its purpose is not to dictate your project structure or to demonstrate a complete sample application, but to provide a set of tools intended to make front-end development robust, easy, and, most importantly, fun. Check out the full feature list below!
Table of Contents
- Getting Started
- CLI Generators
- React (
- Redux (
- react-redux (
- redux-thunk middleware
- react-redux (
- react-router (
- react-router-redux (
- Bundle splitting and CSS extraction
- Sass w/ CSS modules, autoprefixer, and minification
- Koa (
- Flow (
- Babel (
- react-transform-hmr hot reloading for React components
- redbox-react visible error reporting for React components
- babel-plugin-transform-runtime so transforms aren't inlined
- babel-plugin-transform-react-constant-elements save some memory allocation
- babel-plugin-transform-react-remove-prop-types remove
- Uses Standard Style by default, but you're welcome to change this.
Just clone the repo and install the necessary node modules:
$ git clone https://github.com/davezuko/react-redux-starter-kit.git $ cd react-redux-starter-kit $ npm install # Install Node modules listed in ./package.json (may take a while the first time) $ npm start # Compile and launch
Starting a New Project
First, I highly suggest checking out a new project by SpencerCDixon: redux-cli. This tool integrates extremely well with this project and offers added benefits such as generators (components, redux modules, etc.) and config/template management. It's still a work in progress, but give it a shot and file bugs to help make the project more robust.
Alternatively, if you just want to stick with this project and want to start a fresh project without having to clean up the example code in
master, you can do the following after cloning the repo:
git fetch origin new-project # Make sure you've fetched the latest copy of this branch from remote git checkout new-project # Checkout the new-project branch git checkout -b <your-project-name> new-project # Create a branch based on the new-project branch $ npm install # There are a few npm dependencies in this branch that aren't in master $ npm run make:project # Make your new project $ rm -rf .git && git init # Start a new git repository
Before delving into the descriptions of each available npm script, here's a brief summary of the three which will most likely be your bread and butter:
- Doing live development? Use
npm startto spin up the dev server.
- Compiling the application to disk? Use
npm run compile.
- Deploying to an environment?
npm run deploycan help with that.
NOTE: This package makes use of debug to improve your debugging experience. For convenience, all of messages are prefixed with
app:*. If you'd like to to change what debug statements are displayed, you can override the
DEBUG environment variable via the CLI (e.g.
DEBUG=app:* npm start) or tweak the npm scripts (
Great, now that introductions have been made here's everything in full detail:
||Spins up Koa server to serve your app at
||Compiles the application to disk (
||Runs unit tests with Karma and generates a coverage report.|
||Runs Karma and watches for changes to re-run tests; does not generate coverage reports.|
||Runs linter, tests, and then, on success, compiles your application to disk.|
||Analyzes the project for type errors.|
||Lint and fix all
NOTE: Deploying to a specific environment? Make sure to specify your target
NODE_ENV so webpack will use the correct configuration. For example:
NODE_ENV=production npm run compile will compile your application with
Basic project configuration can be found in
~/config/_base.js. Here you'll be able to redefine your
dist directories, adjust compilation settings, tweak your vendor dependencies, and more. For the most part, you should be able to make changes in here without ever having to touch the webpack build configuration.
If you need environment-specific overrides (useful for dynamically setting API endpoints, for example), create a file with the name of target
NODE_ENV prefixed by an
~/config/_production.js). This can be entirely arbitrary, such as
NODE_ENV=staging where the config file is
Common configuration options:
||application source code base path|
||path to build compiled application to|
||hostname for the Koa server|
||port for the Koa server|
||whether or not to enable CSS modules|
||what type of source-maps to generate (set to
||packages to separate into to the vendor bundle|
This project integrates with Redux CLI out of the box. If you used it to generate this project you have immediate access to the generators listed below (if you cloned/forked the project you have these features as well, but make sure to install the CLI first!).
||generates a dumb component and test file|
||generates a smart connected component and test file|
||generates functional layout component|
||generates a view component|
||generates a form component (assumes redux-form)|
||generates a redux duck and test file|
||generates an empty blueprint for you to make|
All of these blueprints are available (and can be overriden) in the
~/blueprints folder so you can customize the
default generators for your project's specific needs. If you have an existing app you can run
redux init to set up the CLI, then
make sure to copy over the
blueprints folder in this project for starter-kit specific generators.
See the Redux CLI github repo for more information on how to create and use blueprints.
The folder structure provided is only meant to serve as a guide, it is by no means prescriptive. It is something that has worked very well for me and my team, but use only what makes sense to you.
. ├── bin # Build/Start scripts ├── blueprints # Blueprint files for redux-cli ├── build # All build-related configuration │ └── webpack # Environment-specific configuration files for webpack ├── config # Project configuration settings ├── interfaces # Type declarations for Flow ├── server # Koa application (uses webpack middleware) │ └── main.js # Server application entry point ├── src # Application source code │ ├── components # Generic React Components (generally Dumb components) │ ├── containers # Components that provide context (e.g. Redux Provider) │ ├── layouts # Components that dictate major page structure │ ├── redux # Redux-specific pieces │ │ ├── modules # Collections of reducers/constants/actions │ │ └── utils # Redux-specific helpers │ ├── routes # Application route definitions │ ├── static # Static assets (not imported anywhere in source code) │ ├── styles # Application-wide styles (generally settings) │ ├── views # Components that live at a route │ └── main.js # Application bootstrap and rendering └── tests # Unit tests
Components vs. Views vs. Layouts
TL;DR: They're all components.
This distinction may not be important for you, but as an explanation: A Layout is something that describes an entire page structure, such as a fixed navigation, viewport, sidebar, and footer. Most applications will probably only have one layout, but keeping these components separate makes their intent clear. Views are components that live at routes, and are generally rendered within a Layout. What this ends up meaning is that, with this structure, nearly everything inside of Components ends up being a dumb component.
You can redefine which packages to bundle separately by modifying
~/config/_base.js. These default to:
[ 'history', 'react', 'react-redux', 'react-router', 'react-router-redux', 'redux' ]
Webpack Root Resolve
Webpack is configured to make use of resolve.root, which lets you import local packages as if you were traversing from the root of your
~/src directory. Here's an example:
// current file: ~/src/views/some/nested/View.js // What used to be this: import SomeComponent from '../../../components/SomeComponent' // Can now be this: import SomeComponent from 'components/SomeComponent' // Hooray!
These are global variables available to you anywhere in your source code. If you wish to modify them, they can be found as the
globals key in
~/config/_base.js. When adding new globals, also add them to
||npm history basename option|
This starter kit comes packaged with an Koa server. It's important to note that the sole purpose of this server is to provide
webpack-hot-middleware for hot module replacement. Using a custom Koa app in place of webpack-dev-server will hopefully make it easier for users to extend the starter kit to include functionality such as back-end API's, isomorphic/universal rendering, and more -- all without bloating the base boilerplate. Because of this, it should be noted that the provided server is not production-ready. If you're deploying to production, take a look at the deployment section.
.css file extensions are supported out of the box and are configured to use CSS Modules. After being imported, styles will be processed with PostCSS for minification and autoprefixing, and will be extracted to a
.css file during production builds.
NOTE: If you're importing styles from a base styles directory (useful for generic, app-wide styles), you can make use of the
styles alias, e.g.:
// current file: ~/src/components/some/nested/component/index.jsx import 'styles/core.scss' // this imports ~/src/styles/core.scss
styles directory is aliased for sass imports, which further eliminates manual directory traversing; this is especially useful for importing variables/mixins.
Here's an example:
// current file: ~/src/styles/some/nested/style.scss // what used to be this (where base is ~/src/styles/_base.scss): @import '../../base'; // can now be this: @import 'base';
To add a unit test, simply create a
.spec.js file anywhere in
~/tests. Karma will pick up on these files automatically, and Mocha and Chai will be available within your test without the need to import them. If you are using
redux-cli, test files should automatically be generated when you create a component or redux module (duck).
Coverage reports will be compiled to
~/coverage by default. If you wish to change what reporters are used and where reports are compiled, you can do so by modifying
Out of the box, this starter kit is deployable by serving the
~/dist folder generated by
npm run compile (make sure to specify your target
NODE_ENV as well). This project does not concern itself with the details of server-side rendering or API structure, since that demands an opinionated structure that makes it difficult to extend the starter kit. However, if you do need help with more advanced deployment strategies, here are a few tips:
If you are serving the application via a web server such as nginx, make sure to direct incoming routes to the root
~/dist/index.html file and let react-router take care of the rest. The Koa server that comes with the starter kit is able to be extended to serve as an API or whatever else you need, but that's entirely up to you.
Have more questions? Feel free to submit an issue or join the Gitter chat!
npm run dev:nw produces
cannot read location of undefined.
This is most likely because the new window has been blocked by your popup blocker, so make sure it's disabled before trying again.
Reference: issue 110
Running into issues with Babel? Babel 6 can be tricky, please either report an issue or try out the stable v0.18.1 release with Babel 5. If you do report an issue, please try to include relevant debugging information such as your node, npm, and babel versions.
In keeping with the goals of this project, no internationalization support is provided out of the box. However, juanda99 has been kind enough to maintain a fork of this repo with internationalization support, check it out!
High editor CPU usage after compilation
While this is common to any sizable application, it's worth noting for those who may not know: if you happen to notice higher CPU usage in your editor after compiling the application, you may need to tell your editor not to process the dist folder. For example, in Sublime you can add:
"folder_exclude_patterns": [".svn", ".git", ".hg", "CVS", "node_modules", "dist"]