Provides a generic API for using template engines such as Handlebars and
Y.Template.Micro.
Using with Y.Template.Micro (the default template engine):
YUI().use('template', function (Y) {
var micro = new Y.Template(),
html = micro.render('<%= data.message %>', {message: 'hello!'});
// ...
});Using with Handlebars:
YUI().use('template-base', 'handlebars', function (Y) {
var handlebars = new Y.Template(Y.Handlebars),
html = handlebars.render('{{message}}', {message: 'hello!'});
// ...
});Template[engine=Y.Template.Micro]
[defaults]
[engine=Y.Template.Micro]
Mixed
optional
Template engine to use, such as
Y.Template.Micro or Y.Handlebars. Defaults to Y.Template.Micro if not
specified.
[defaults]
Object
optional
Default options to use when instance methods are invoked.
compiletext
[options]
Compiles a template with the current template engine and returns a compiled template function.
Compiled template function.
gettemplateName
Returns the registered template function, given the template name. If an
unregistered template is accessed, this will return undefined.
templateName
String
The template name.
revivedTemplate The revived template function, or undefined
if it has not been registered.
precompiletext
[options]
Precompiles a template with the current template engine and returns a string containing JavaScript source code for the precompiled template.
Source code for the precompiled template.
registertemplateName
template
Registers a pre-compiled template into the central template registry with a
given template string, allowing that template to be called and rendered by
that name using the Y.Template.render() static method.
For example, given the following simple Handlebars template, in foo.hbs:
revivedTemplate This is the same function as in template,
and is done to maintain compatibility with the Y.Template#revive() method.
<p>{{tagline}}</p>It can be precompiled using the Handlebars CLI, and added into a YUI module
in the following way. Alternatively, locator can be used to automate this
process for you:
YUI.add('templates-foo', function (Y) {
var engine = new Y.Template(Y.Handlebars),
precompiled;
precompiled = // Long precompiled template function here //
Y.Template.register('foo', engine.revive(precompiled));
}, '0.0.1', {requires: ['template-base', 'handlebars-base']});See the Y.Template#render method to see how a registered template is used.
rendertemplateName
[data]
[options]
Renders a template into a string, given the registered template name and data
to be interpolated. The template name must have been registered previously with
register().
Once the template has been registered and built into a YUI module, it can be listed as a dependency for any other YUI module. Continuing from the above example, the registered template can be used in the following way:
output The rendered result.
YUI.add('bar', function (Y) {
var html = Y.Template.render('foo', {
tagline: '"bar" is now template language agnostic'
});
}, '0.0.1', {requires: ['template-base', 'templates-foo']});The template can now be used without having to know which specific rendering engine generated it.
rendertext
data
[options]
Compiles and renders a template with the current template engine in a single step, and returns the rendered result.
Rendered result.
reviveprecompiled
[options]
Revives a precompiled template function into an executable template function using the current template engine. The precompiled code must already have been evaluated; this method won't evaluate it for you.
Compiled template function.