react-snap

Zero-configuration framework-agnostic static prerendering for SPAs

ReactBrowser automationPrerender
stereobooster/react-snapreact-snap

README

Stand With Ukraine

react-snap Build Status npm npm Twitter Follow


Pre-renders a web app into static HTML. Uses Headless Chrome to crawl all available links starting from the root. Heavily inspired by prep and react-snapshot, but written from scratch. Uses best practices to get the best loading performance.

😍 Features


- Enables SEO (Google, DuckDuckGo...) and SMO (Twitter, Facebook...) for SPAs.
- Works out-of-the-box with create-react-app - no code-changes required.
- Uses a real browser behind the scenes, so there are no issues with unsupported HTML5 features, like WebGL or Blobs.
- Does a lot of load performance optimization. Here are details, if you are curious.
- Does not depend on React. The name is inspired by react-snapshot but works with any technology (e.g., Vue).
- npm package does not have a compilation step, so you can fork it, change what you need, and install it with a GitHub URL.

Zero configuration is the main feature. You do not need to worry about how it works or how to configure it. But if you are curious, here are details.

Basic usage with create-react-app


Install:

  1. ```sh
  2. yarn add --dev react-snap
  3. ```

Change package.json:

  1. ```json
  2. "scripts": {
  3.   "postbuild": "react-snap"
  4. }
  5. ```

Change src/index.js (for React 16+):

  1. ```js
  2. import { hydrate, render } from "react-dom";

  4. const rootElement = document.getElementById("root");
  5. if (rootElement.hasChildNodes()) {
  6.   hydrate(<App />, rootElement);
  7. } else {
  8.   render(<App />, rootElement);
  9. }
  10. ```

That's it!

Basic usage with Preact


To do hydration in Preact you need to use this trick:

  1. ```js
  2. const rootElement = document.getElementById("root");
  3. if (rootElement.hasChildNodes()) {
  4.   preact.render(<App />, rootElement, rootElement.firstElementChild);
  5. } else {
  6.   preact.render(<App />, rootElement);
  7. }
  8. ```

Basic usage with Vue.js


Install:

  1. ```sh
  2. yarn add --dev react-snap
  3. ```

Change package.json:

  1. ```json
  2. "scripts": {
  3.   "postbuild": "react-snap"
  4. },
  5. "reactSnap": {
  6.   "source": "dist",
  7.   "minifyHtml": {
  8.     "collapseWhitespace": false,
  9.     "removeComments": false
  10.   }
  11. }
  12. ```

Or use preserveWhitespace: false in vue-loader.

source - output folder of webpack or any other bundler of your choice

Read more about minifyHtml caveats in #142.

Example: Switch from prerender-spa-plugin to react-snap

Caveats


Only works with routing strategies using the HTML5 history API. No hash(bang) URLs.

Vue uses the data-server-rendered attribute on the root element to mark SSR generated markup. When this attribute is present, the VDOM rehydrates instead of rendering everything from scratch, which can result in a flash.

This is a small hack to fix rehydration problem:

  1. ```js
  2. window.snapSaveState = () => {
  3.   document.querySelector("#app").setAttribute("data-server-rendered", "true");
  4. };
  5. ```

window.snapSaveState is a callback to save the state of the application at the end of rendering. It can be used for Redux or async components. In this example, it is repurposed to alter the DOM, this is why I call it a "hack." Maybe in future versions of react-snap, I will come up with better abstractions or automate this process.

Vue 1.x


Make sure to use [replace: false](https://v1.vuejs.org/api/#replace) for root components

✨ Examples


- Emotion website load performance optimization
- Load performance optimization
- recipes
- stereobooster/an-almost-static-stack

⚙️ Customization


If you need to pass some options for react-snap, you can do this in your package.json like this:

  1. ```json
  2. "reactSnap": {
  3.   "inlineCss": true
  4. }
  5. ```

Not all options are documented yet, but you can check defaultOptions in index.js.

inlineCss


Experimental feature - requires improvements.

react-snap can inline critical CSS with the help of minimalcss and full CSS will be loaded in a non-blocking manner with the help of loadCss.

Use inlineCss: true to enable this feature.

TODO: as soon as this feature is stable, it should be enabled by default.

⚠️ Caveats


Async components


Also known as code splitting, dynamic import (TC39 proposal), "chunks" (which are loaded on demand), "layers", "rollups", or "fragments". See: Guide To JavaScript Async Components

An async component (in React) is a technique (typically implemented as a higher-order component) for loading components on demand with the dynamic import operator. There are a lot of solutions in this field. Here are some examples:

- [react.lazy](https://reactjs.org/docs/code-splitting.html#reactlazy)
- [loadable-components](https://github.com/smooth-code/loadable-components)
- [react-loadable](https://github.com/thejameskyle/react-loadable)
- [react-async-component](https://github.com/ctrlplusb/react-async-component)

It is not a problem to render async components with react-snap, the tricky part happens when a prerendered React application boots and async components are not loaded yet, so React draws the "loading" state of a component, and later when the component is loaded, React draws the actual component. As a result, the user sees a flash:

  1. ```
  2. 100%                    /----|    |----
  3.                        /     |    |
  4.                       /      |    |
  5.                      /       |    |
  6.                     /        |____|
  7.   visual progress  /
  8.                   /
  9. 0%  -------------/
  10. ```

Usually a _code splitting_ library provides an API to handle it during SSR, but as long as "real" SSR is not used in react-snap - the issue surfaces, and there is no simple way to fix it.

1. Use react-prerendered-component. This library holds onto the prerendered HTML until the dynamically imported code is ready.

  1. ```js
  2. import loadable from "@loadable/component";
  3. import { PrerenderedComponent } from "react-prerendered-component";

  5. const prerenderedLoadable = dynamicImport => {
  6.   const LoadableComponent = loadable(dynamicImport);
  7.   return React.memo(props => (
  8.     // you can use the `.preload()` method from react-loadable or react-imported-component`
  9.     <PrerenderedComponent live={LoadableComponent.load()}>
  10.       <LoadableComponent {...props} />
  11.     </PrerenderedComponent>
  12.   ));
  13. };

  15. const MyComponent = prerenderedLoadable(() => import("./MyComponent"));
  16. ```

MyComponent will use prerendered HTML to prevent the page content from flashing (it will find the required piece of HTML using an id attribute generated by PrerenderedComponent and inject it using dangerouslySetInnerHTML).

2. The same approach will work with React.lazy, but React.lazy doesn't provide a prefetch method (load or preload), so you need to implement it yourself (this can be a fragile solution).

  1. ```js
  2. const prefetchMap = new WeakMap();
  3. const prefetchLazy = LazyComponent => {
  4.   if (!prefetchMap.has(LazyComponent)) {
  5.     prefetchMap.set(LazyComponent, LazyComponent._ctor());
  6.   }
  7.   return prefetchMap.get(LazyComponent);
  8. };

  10. const prerenderedLazy = dynamicImport => {
  11.   const LazyComponent = React.lazy(dynamicImport);
  12.   return React.memo(props => (
  13.     <PrerenderedComponent live={prefetchLazy(LazyComponent)}>
  14.       <LazyComponent {...props} />
  15.     </PrerenderedComponent>
  16.   ));
  17. };

  19. const MyComponent = prerenderedLazy(() => import("./MyComponent"));
  20. ```

3. use loadable-components 2.2.3 (current is >5). The old version of loadable-components can solve this issue for a "snapshot" setup:

  1. ```js
  2. import { loadComponents, getState } from "loadable-components";
  3. window.snapSaveState = () => getState();

  5. loadComponents()
  6.   .then(() => hydrate(AppWithRouter, rootElement))
  7.   .catch(() => render(AppWithRouter, rootElement));
  8. ```

If you don't use babel plugin, don't forget to provide modules:

  1. ```js
  2. const NotFoundPage = loadable(() => import("src/pages/NotFoundPage"), {
  3.   modules: ["NotFoundPage"]
  4. });
  5. ```

loadable-components were deprecated in favour of @loadable/component, but @loadable/component dropped getState. So if you want to use loadable-components you can use old version (2.2.3 latest version at the moment of writing) or you can wait until React will implement proper handling of this case with asynchronous rendering and React.lazy.


Redux


See: Redux Server Rendering Section

  1. ```js
  2. // Grab the state from a global variable injected into the server-generated HTML
  3. const preloadedState = window.__PRELOADED_STATE__;

  5. // Allow the passed state to be garbage-collected
  6. delete window.__PRELOADED_STATE__;

  8. // Create Redux store with initial state
  9. const store = createStore(counterApp, preloadedState || initialState);

  11. // Tell react-snap how to save Redux state
  12. window.snapSaveState = () => ({
  13.   __PRELOADED_STATE__: store.getState()
  14. });
  15. ```

Caution: as of now, only basic "JSON" data types are supported: e.g. Date, Set, Map, and NaN won't be handled correctly (#54).

Third-party requests: Google Analytics, Mapbox, etc.


You can block all third-party requests with the following config:

  1. ```json
  2. "skipThirdPartyRequests": true
  3. ```

AJAX


`react-snap` can capture all AJAX requests. It will store `json` requests in the domain in `window.snapStore[]`, where `` is the path of the request.

Use "cacheAjaxRequests": true to enable this feature.

This feature can conflict with the browser cache. See #197 for details. You may want to disable cache in this case:"puppeteer": { "cache": false }.

Service Workers


By default, create-react-app uses index.html as a fallback:

  1. ```json
  2. navigateFallback publicUrl + '/index.html',
  3. ```

You need to change this to an un-prerendered version of index.html - 200.html, otherwise you will see index.html flash on other pages (if you have any). See Configure sw-precache without ejecting for more information.

Containers and other restricted environments


Puppeteer (Headless Chrome) may fail due to sandboxing issues. To get around this,
you may use:

  1. ```json
  2. "puppeteerArgs": ["--no-sandbox", "--disable-setuid-sandbox"]
  3. ```

Read more about puppeteer troubleshooting.

"inlineCss": true sometimes causes problems in containers.

Docker + Alpine


To run react-snap inside docker with Alpine, you might want to use a custom Chromium executable. See #93 and #132.

Heroku


  1. ```
  2. heroku buildpacks:add https://github.com/jontewks/puppeteer-heroku-buildpack.git
  3. heroku buildpacks:add heroku/nodejs
  4. heroku buildpacks:add https://github.com/heroku/heroku-buildpack-static.git
  5. ```

See this PR. At the moment of writing, Heroku doesn't support HTTP/2.

Semantic UI


Semantic UI is defined over class substrings that contain spaces
(e.g., "three column"). Sorting the class names, therefore, breaks the styling. To get around this,
use the following configuration:

  1. ```json
  2. "minifyHtml": { "sortClassName": false }
  3. ```

From version 1.17.0, sortClassName is false by default.

JSS


Once JS on the client is loaded, components initialized and your JSS styles are regenerated, it's a good time to remove server-side generated style tag in order to avoid side-effects

>

https://github.com/cssinjs/jss/blob/master/docs/ssr.md


This basically means that JSS doesn't support rehydration. See #99 for a possible solutions.

react-router v3


See #135.

userAgent


You can use navigator.userAgent == "ReactSnap" to do some checks in the app code while snapping—for example, if you use an absolute path for your API AJAX request. While crawling, however, you should request a specific host.

Example code:

  1. ```js
  2. const BASE_URL =
  3.   process.env.NODE_ENV == "production" && navigator.userAgent != "ReactSnap"
  4.     ? "/"
  5.     : "http://xxx.yy/rest-api";
  6. ```

Alternatives


See alternatives.

Who uses it


[![cloud.gov.au](doc/who-uses-it/cloud.gov.au.png)](https://github.com/govau/cloud.gov.au/blob/0187dd78d8f1751923631d3ff16e0fbe4a82bcc6/www/ui/package.json#L29)[![blacklane](doc/who-uses-it/blacklane.png)](http://m.blacklane.com/)[![reformma](doc/who-uses-it/reformma.png)](http://reformma.com)
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


Contributing


Report a bug


Please provide a reproducible demo of a bug and steps to reproduce it. Thanks!

Share on the web


Tweet it, like it, share it, star it. Thank you.

Code


You can also contribute to minimalcss, which is a big part ofreact-snap. Also, give it some stars.