React 16 Tooling

Table of contents

1. Title Page
2. Copyright and Credits
   1. React 16 Tooling
3. Packt Upsell
   1. Why subscribe?
   2. PacktPub.com
4. Contributors
   1. About the author
   2. About the reviewer
   3. Packt is searching for authors like you
5. Preface
   1. Who this book is for
   2. What this book covers
   3. To get the most out of this book
      1. Download the example code files
      2. Download the color images
      3. Conventions used
   4. Get in touch
      1. Reviews
6. Creating a Personalized React Development Ecosystem
   1. What's included with React
      1. Components that compare render trees
      2. The DOM render target
   2. Introducing tooling?
      1. Ancillary tasks outside of React
      2. A construction site analogy
   3. React tooling covered in this book
      1. JSX needs to be compiled to JavaScript
      2. Newer JavaScript language features need to be transpiled
      3. Hot module loading to enable application development
      4. Running unit tests automatically
      5. Thinking about type safety
      6. Linting for code quality
      7. Isolating component development environments
      8. Providing a browser-based debugging environment
      9. Deploying React applications
   4. Choosing the right tools
      1. Essential tools
      2. Optional tools
   5. Summary
7. Efficiently Bootstrapping React Applications with Create React App
   1. Installing Create React App
      1. Creating your first app
         1. Specifying a project name
         2. Automatic dependency handling
         3. Directory structure
            1. Top-level files
            2. Static assets
            3. Source code
   2. Summary
8. Development Mode and Mastering Hot Reloading
   1. Starting the development server
      1. Webpack configuration
         1. Entry points
         2. Build output
         3. Resolving input files
         4. Loading and compiling files
         5. Configuring plugins
         6. Hot reloading
      2. Hot component reloading in action
      3. Ejecting from Create React App
   2. Summary
9. Optimizing Test-Driven React Development
   1. The driving philosophy of Jest
      1. Mock everything except the application code
      2. Isolate tests and run in parallel
         1. Tests should feel natural
   2. Running tests
      1. Running tests using react-scripts
      2. Running tests using standalone Jest
   3. Writing Jest tests
      1. Organizing tests using suites
      2. Basic assertions
         1. Basic equality
         2. Approximate equality
         3. Value equality
         4. Values in collections
         5. Working with mocks
         6. Asynchronous assertions
         7. React component snapshots
      3. Unit test coverage
   4. Summary
10. Streamlining Development and Refactoring with Type-Safe React Components
    1. What does type-safety solve?
       1. Replacing guesswork with assurance
       2. Removing runtime checks
       3. Obvious low-severity bugs
    2. Installing and initializing Flow
    3. Validating component properties and state
       1. Primitive property values
       2. Object property values
       3. Validating component state
       4. Function property values
       5. Enforcing child component types
          1. Parents with specific children types
          2. Parents with one child
          3. Parents with an optional child
          4. Parents with primitive child values
    4. Validating event handler functions
    5. Bringing Flow into the development server
    6. Bringing Flow into your editor
    7. Summary
11. Enforcing Code Quality to Improve Maintainability
    1. Installing and configuring ESLint
    2. Building on Airbnb standards
    3. Adding React plugins to ESLint
    4. Using ESLint with create-react-app
    5. Using ESLint in a code editor
    6. Automating code formatting with Prettier
    7. Summary
12. Isolating Components with Storybook
    1. The need for isolated component development
    2. Installing and configuring Storybook
    3. Developing components with stories
       1. Experimenting with props
       2. Experimenting with actions
       3. Linking stories together
       4. Stories as documentation
    4. Building static Storybook apps
    5. Summary
13. Debugging Components in the Browser
    1. Installing the React Developer Tools add-on
    2. Working with React elements in React Developer Tools
       1. Selecting React elements
       2. Searching for React elements
    3. Inspecting component properties and state
    4. Manipulating element state values
    5. Profiling component performance
       1. Removing reconciliation work
       2. Finding CPU intensive components
    6. Summary
14. Instrumenting Application State with Redux
    1. Building a Redux app
       1. The App component and state
       2. The Home component and state
       3. The NewBook component and state
       4. The API abstraction
       5. Putting it all together
    2. Installing Redux DevTools
    3. Selecting and examining actions
       1. Action data
       2. Action state trees and charts
       3. Action state diffs
    4. Time travel debugging
    5. Manually triggering actions
    6. Exporting and importing state
    7. Summary
15. Building and Deploying Static React Sites with Gatsby
    1. Why static React sites?
       1. Types of React apps
       2. Better user experience
       3. Efficient resource usage
    2. Building your first Gatsby site
    3. Adding local filesystem data
    4. Fetching remote data
    5. Summary
16. Building and Deploying React Applications with Docker Containers
    1. Building a messaging app
       1. Starting Barely SMS
       2. Logging in
       3. The home page
       4. The contacts page
       5. The messages page
       6. Sending a message
       7. The API
    2. Getting started with Node containers
    3. Composing React apps with services
    4. Static React builds for production
    5. Summary
17. Another Book You May Enjoy
    1. Leave a review – let other readers know what you think