template

yyx990803 · yyx990803 · commit 9bfd11650545 · 2017-04-26T11:13:55.000+08:00
diff --git a/en/api.md b/en/api.md
@@ -0,0 +1,25 @@
+# API Reference
+
+## Top-Level APIs
+
+### `createRenderer`
+
+### `createBundleRenderer`
+
+## Renderer Options
+
+### `basedir`
+
+### `cache`
+
+### `directives`
+
+### `template`
+
+### `clientManifest`
+
+### `inject`
+
+### `shouldPreload`
+
+### `runInNewContext`
diff --git a/en/basic.md b/en/basic.md
@@ -103,9 +103,43 @@ renderer.renderToString(app, (err, html) => {
 })
 ```
 
-The template also supports many advanced features like:
+### Template Interpolation
+
+The template also supports simple interpolation. Given the following template:
+
+``` html
+<html>
+  <head>
+    <title>{{ title }}</title>
+    {{{ meta }}}
+  </head>
+  <body>
+    <!--vue-ssr-outlet-->
+  </body>
+</html>
+```
+
+We can provide interpolation data by passing a "render context object" as the second argument to `renderToString`:
+
+``` js
+const context = {
+  title: 'hello',
+  meta: `
+    <meta ...>
+    <meta ...>
+  `
+}
+
+renderer.renderToString(app, context, (err, html) => {
+  // page title will be "hello"
+  // with meta tags injected
+})
+```
+
+The `context` object can also be shared with the Vue app instance, allowing components to dynamically register data for template interpolation.
+
+In addition, the template supports some advanced features such as:
 
-- Interpolation using a render context;
 - Auto injection of critical CSS when using `*.vue` components;
 - Auto injection of asset links and resource hints when using `clientManifest`;
 - Auto injection and XSS prevention when embedding Vuex state for client-side hydration.
diff --git a/en/build-config.md b/en/build-config.md
@@ -136,7 +136,9 @@ With this setup, your server-rendered HTML for a build with code-splitting will
 
 ### Manual Asset Injection
 
-Sometimes you might want finer-grained control over how assets are injected into the template, or maybe you are not using a template at all. In the `renderToString` callback, the `context` object you passed in will expose the following methods:
+By default, asset injection is automatic when you provide the `template` render option. But sometimes you might want finer-grained control over how assets are injected into the template, or maybe you are not using a template at all. In such a case, you can pass `inject: false` when creating the renderer and manually perform asset injection.
+
+In the `renderToString` callback, the `context` object you passed in will expose the following methods:
 
 - `context.renderStyles()`
 
@@ -176,11 +178,12 @@ Sometimes you might want finer-grained control over how assets are injected into
 
   Preloaded files can be further customized with the `shouldPreload` option.
 
-Since the `template` passed to `createBundleRenderer` will be interpolated using `context`, you can make use of these methods inside the template (make sure to use triple-mustaches):
+Since the `template` passed to `createBundleRenderer` will be interpolated using `context`, you can make use of these methods inside the template (with `inject: false`):
 
 ``` html
 <html>
   <head>
+    <!-- use triple mustache for non-HTML-escaped interpolation -->
     {{{ renderResourceHints() }}}
     {{{ renderStyles() }}}
   </head>
diff --git a/en/template.md b/en/template.md
