A set of React components implementing Google's Material Design specification with the power of CSS Modules.
React Toolbox is a set of React components that implement Google's Material Design specification. It's powered by CSS Modules and harmoniously integrates with your webpack workflow, although you can use any other module bundler. You can take a tour through our documentation website and try the components live!
Note: This source code refers to the future version. To check the source for
1.x go to
master branch. We are currently writing a migration guide so you can start working with 2.0-beta.x now!
React Toolbox can be installed as an npm package:
$ npm install --save react-toolbox
React Toolbox uses CSS Modules by default to import stylesheets written in SASS. In case you want to import the components already bundled with CSS, your module bundler should be able to require these SASS modules.
Although we recommend webpack, you are free to use whatever module bundler you want as long as it can compile and require SASS files located in your
node_modules. If you are experiencing require errors, make sure your configuration satisfies this requirement.
Of course this is a set of React components so you should be familiar with React. If want to customize your components via themes, you may want to take a look to react-css-themr which is used by React Toolbox to make components easily themeable.
In this minimal example, we import a
Button with styles already bundled:
Take into account that any required style will be included in the final CSS so your final would include
Button styles in this case. It's more convenient to import components this way (or with raw imports) because if you require from the project root, every stylesheet of React Toolbox will be included, even if you don't use it.
First let's take a look on how the components are structured in the project. The components folder contains a folder for each component or set of related components. For example, the
|- /app_bar|---- AppBar.js|---- _config.scss|---- index.js|---- readme.md|---- theme.scss
If you import from the index file, the imported component comes with all dependencies and themes already required and injected for you. This means that the CSS for each dependency will be bundled in your final CSS automatically and the component markup includes the classnames to be styled. For example:
If you import from the component definition, the imported component is bundled with its dependencies, but it does not include any styles. This means no CSS will be bundled, and the component markup will not include any classname. It's your responsibility to provide a theme to the component to be properly styled. You can do so via properties or context. For example:
Every component accepts a
theme property intended to provide a CSS Module import object that will be used by the component to assign local classnames to its DOM nodes. Therefore, each one implements a documented classname API. So if you want to customize a component, you just need to provide a theme object with the appropriated classname mapping.
If the component already has a theme injected, the properties you pass will be merged with the injected theme. In this way, you can add classnames to the nodes of a specific component and use them to add or to override styles. For example, if you want to customize the
AppBar to be purple:
;;;const PurpleAppBar =<AppBar ...props theme=theme />;;
In this case we are adding styles to an
AppBar component that already has some styles injected. It works because the component background by default has the same priority as the one we added. There will be cases where the original rule is more restrictive. For those cases you would need to boost priority using the same restrictions as in the original stylesheet. Feel free to take a look into the original themes or just check the selectors you want to override in DevTools.
If the component has no styles injected, you should provide a theme object implementing the full API. You are free to require the CSS Module you want but take into account that every classname is there for a reason. You can either provide a theme via prop or via context as we will see later.
You can afford theming in multiple ways. First of all, you have to understand that React Toolbox stylesheets are written in SASS and configured using the config files we saw earlier. Also you may want to check colors and globals files to get an overview on the variables you have to override to get the results you want.
In most scenarios you can get more customized themes by overriding those variables and compiling stylesheets with them. For example, you can create a
_theme.scss SASS file:
This file should be prepended to each stylesheet compilation which can be achieved in multiple ways.
If you are using Webpack as module bundler, you are probably using sass-loader as well. What we want to do is to prepend to each SASS file compilation a bunch of variables to override. This can be done with the
data option. For example:
sassLoader:data: '@import "' + path + '";'
In this case we are prepending the theme import to each SASS compilation so the primary color will be changed in every single stylesheet. If you are not using webpack, maybe your loader still has a similar option. Otherwise, don't worry, there are solutions.
Remember that you can import components without styles and provide those styles using the theme property. For example, a theme for a button customized with the previous theme file would be like:
Then, when you use a button, you can inject the appropriate theme:
;;const ThemedButton =<Button theme=buttonTheme ...props />;;
With this technique you have to create wrappers for every component, and this is not cool at all... but don't worry, we can provide the theme via context to avoid this.
This is a good moment to check out react-css-themr if you still didn't. Every component in React Toolbox has a key assigned that can be used to provide a default CSS Module. You can create a theme like:
Check for each component what key uses. Then, when you have a theme object fully imported and customized for each component your application uses, you can use it like we list here:
A couple of things here. First you need to use raw components to get this styles properly applied. Second, you have to add dependency themes by yourself. For example, the
Ripple so you have to provide styles for both of them.
Also, recall that all components accept a theme verifying required classNames but there may be some missing. If any property is missing you can check the selectors you want to override straight in the DevTools.
In order to import the fonts for you, we'd need to include them in the CSS which is considered a bad practice. If you are not including them in your app, go to the linked sites and follow the instructions.
The only requirement for SSR is to be able to require ES6 and CSS Modules in the backend. To make it possible you can check projects like CSS Modules register hook or Webpack Isomorphic tools. Also, make sure you can import from
For now we have a repository example demonstrating configuration and some basic customization. For now it's not using SSR rendering but it shouldn't be difficult to implement an example so it will come soon. Feel free to PR your example project or to add some use cases to the repository.
TypeScript external module definition files are included, and should not require any manual steps to utilize. They will be picked up by the TypeScript compiler when importing from the npm package.
Note that to comply with the official recommendation for npm typings, a triple-slash reference to
react.d.ts is NOT included. You will need to reference react.d.ts somewhere in your project.
The project is being initially developed and maintained by Javier Velasco and Javier Jiménez and the contribution scene is just getting warm. We want to create reference components so any contribution is very welcome.
To work in the project you'd need a
node version supporting ES6 syntax. Although the project is built using Babel we use some ES6 features in the development server. Also, the package has been tested with
node 4.2.1. Consider using nvm or n to handle different node versions!
To start the documentation site locally, you'll need to install the dependencies from both the main package and the docs subproject:
$ git clone$ cd react-toolbox/$ npm install$ cd docs/$ npm install$ npm start
Local documentation will then be available at
We don't officially support components that are not covered by Google Material Design. If you want to implement some complementary component feel free to open a PR adding your a link in this section. For now you can check on github: react-toolbox-additions and on npm: react-toolbox-additions.
This project is licensed under the terms of the MIT license.