This is an Express view engine which renders React components on server. It renders static markup and does not support mounting those views on the client.
This is intended to be used as a replacement for existing server-side view solutions, like jade, ejs, or handlebars.
npm install express-react-views
// app.js
var app = express();
app.set('view engine', 'jsx');
app.engine('jsx', require('express-react-views').createEngine());
Beginning with v0.2, you can now pass options in when creating your engine.
option | values | default |
---|---|---|
jsx.harmony |
true : enable a subset of ES6 features |
false |
jsx.extension |
any file extension with leading . |
".jsx" |
doctype |
any string that can be used as a doctype, this will be prepended to your document | "<!DOCTYPE html>" |
The defaults are sane, but just in case you want to change something, here's how it would look:
var options = { jsx: { harmony: true } };
app.engine('jsx', require('express-react-views').createEngine(options))
Your views should be node modules that export a React component. Let's assume you have this file in views/index.jsx
:
/** @jsx React.DOM */
var HelloMessage = React.createClass({
render: function() {
return <div>Hello {this.props.name}</div>;
}
});
module.exports = HelloMessage
Your routes would look identical to the default routes Express gives you out of the box.
// app.js
app.get('/', require('./routes').index);
// routes/index.js
exports.index = function(req, res){
res.render('index', { name: 'John' });
};
That's it! Layouts follow really naturally from the idea of composition.
Simply pass the relevant props to a layout component.
views/layouts/default.jsx
:
/** @jsx React.DOM */
var DefaultLayout = React.createClass({
render: function() {
return (
<html>
<head><title>{this.props.title}</title></head>
<body>{this.props.children}</body>
</html>
);
}
});
module.exports = DefaultLayout;
views/index.jsx
:
/** @jsx React.DOM */
var DefaultLayout = require('./layouts/default');
var HelloMessage = React.createClass({
render: function() {
return (
<DefaultLayout title={this.props.title}>
<div>Hello {this.props.name}</div>
</DefaultLayout>
);
}
});
module.exports = HelloMessage;
These ideas don't really apply. But since they are familiar ideas to people coming from more traditional "templating" solutions, let's address it. Most of these can be solved by packaging up another component that encapsulates that piece of functionality.
I know you're used to registering helpers with your view helper (hbs.registerHelper('something', ...))
) and operating on strings. But you don't need to do that here.
- Many helpers can be turned into components. Then you can just require and use them in your view.
- You have access to everything else in JS. If you want to do some date formatting, you can
require('moment')
and use directly in your view. You can bundle up other helpers as you please.
All "locals" are exposed to your view in this.props
. These should work identically to other view engines, with the exception of how they are exposed. Using this.props
follows the pattern of passing data into a React component, which is why we do it that way. Remember, as with other engines, rendering is synchronous. If you have database access or other async operations, they should be done in your routes.
- I'm saying it again to avoid confusion: this does not do anything with React in the browser. This is only a solution for server-side rendering.
- This currently uses
require
to access your views. This means that contents are cached for the lifetime of the server process. You need to restart your server when making changes to your views. - React & JSX have their own rendering caveats. For example, inline
<script>
s and<style>
s will need to usedangerouslySetInnerHTML={{__html: 'script content'}}
. You can take advantage of ES6 template strings here.
<script dangerouslySetInnerHTML={{__html: `
// google analtyics
// is a common use
`}} />
- It's not possible to specify a doctype in JSX. You can override the default HTML5 doctype in the options.