--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/template-base/template-base.js Mon Mar 10 15:19:48 2014 +0100
@@ -0,0 +1,272 @@
+YUI.add('template-base', function (Y, NAME) {
+
+/**
+Virtual rollup of the `template-base` and `template-micro` modules.
+
+@module template
+@main template
+@since 3.8.0
+**/
+
+/**
+Provides a generic API for using template engines such as Handlebars and
+`Y.Template.Micro`.
+
+@module template
+@submodule template-base
+@since 3.8.0
+**/
+
+/**
+Provides a generic API for using template engines such as Handlebars and
+`Y.Template.Micro`.
+
+### Examples
+
+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!'});
+
+ // ...
+ });
+
+@class Template
+@param {Mixed} [engine=Y.Template.Micro] Template engine to use, such as
+ `Y.Template.Micro` or `Y.Handlebars`. Defaults to `Y.Template.Micro` if not
+ specified.
+@param {Object} [defaults] Default options to use when instance methods are
+ invoked.
+@constructor
+@since 3.8.0
+**/
+
+function Template(engine, defaults) {
+ /**
+ Default options.
+
+ @property {Object} defaults
+ @since 3.8.1
+ **/
+ this.defaults = defaults;
+
+ /**
+ Template engine class.
+
+ @property {Mixed} engine
+ @since 3.8.0
+ **/
+ this.engine = engine || Y.Template.Micro;
+
+ if (!this.engine) {
+ Y.error('No template engine loaded.');
+ }
+}
+
+/**
+Registry that maps template names to revived template functions.
+
+@property _registry
+@type Object
+@static
+@protected
+@since 3.12.0
+**/
+Template._registry = {};
+
+/**
+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`:
+@example
+ <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:
+@example
+ 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.
+
+@method register
+@param {String} templateName The template name.
+@param {Function} template The function that returns the rendered string. The
+ function should take the following parameters. If a pre-compiled template
+ does not accept these parameters, it is up to the developer to normalize it.
+ @param {Object} [template.data] Data object to provide when rendering the
+ template.
+ @param {Object} [template.options] Options to pass along to the template
+ engine. See template engine docs for options supported by each engine.
+@return {Function} revivedTemplate This is the same function as in `template`,
+ and is done to maintain compatibility with the `Y.Template#revive()` method.
+@static
+@since 3.12.0
+**/
+Template.register = function (templateName, template) {
+ Template._registry[templateName] = template;
+ return template;
+};
+
+/**
+Returns the registered template function, given the template name. If an
+unregistered template is accessed, this will return `undefined`.
+
+@method get
+@param {String} templateName The template name.
+@return {Function} revivedTemplate The revived template function, or `undefined`
+ if it has not been registered.
+@static
+@since 3.12.0
+**/
+
+Template.get = function (templateName) {
+ return Template._registry[templateName];
+}
+
+/**
+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:
+
+@example
+ 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.
+
+@method render
+@param {String} templateName The abstracted name to reference the template.
+@param {Object} [data] The data to be interpolated into the template.
+@param {Object} [options] Any additional options to be passed into the template.
+@return {String} output The rendered result.
+@static
+@since 3.12.0
+**/
+Template.render = function (templateName, data, options) {
+ var template = Template._registry[templateName],
+ result = '';
+
+ if (template) {
+ result = template(data, options);
+ } else {
+ Y.error('Unregistered template: "' + templateName + '"');
+ }
+
+ return result;
+};
+
+Template.prototype = {
+ /**
+ Compiles a template with the current template engine and returns a compiled
+ template function.
+
+ @method compile
+ @param {String} text Template text to compile.
+ @param {Object} [options] Options to pass along to the template engine. See
+ template engine docs for options supported by each engine.
+ @return {Function} Compiled template function.
+ @since 3.8.0
+ **/
+ compile: function (text, options) {
+ options = options ? Y.merge(this.defaults, options) : this.defaults;
+ return this.engine.compile(text, options);
+ },
+
+ /**
+ Precompiles a template with the current template engine and returns a string
+ containing JavaScript source code for the precompiled template.
+
+ @method precompile
+ @param {String} text Template text to compile.
+ @param {Object} [options] Options to pass along to the template engine. See
+ template engine docs for options supported by each engine.
+ @return {String} Source code for the precompiled template.
+ @since 3.8.0
+ **/
+ precompile: function (text, options) {
+ options = options ? Y.merge(this.defaults, options) : this.defaults;
+ return this.engine.precompile(text, options);
+ },
+
+ /**
+ Compiles and renders a template with the current template engine in a single
+ step, and returns the rendered result.
+
+ @method render
+ @param {String} text Template text to render.
+ @param {Object} data Data object to provide when rendering the template.
+ @param {Object} [options] Options to pass along to the template engine. See
+ template engine docs for options supported by each engine.
+ @return {String} Rendered result.
+ @since 3.8.0
+ **/
+ render: function (text, data, options) {
+ options = options ? Y.merge(this.defaults, options) : this.defaults;
+
+ if (this.engine.render) {
+ return this.engine.render(text, data, options);
+ }
+
+ return this.engine.compile(text, options)(data, 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.
+
+ @method revive
+ @param {Function} precompiled Precompiled template function.
+ @param {Object} [options] Options to pass along to the template engine. See
+ template engine docs for options supported by each engine.
+ @return {Function} Compiled template function.
+ @since 3.8.0
+ **/
+ revive: function (precompiled, options) {
+ options = options ? Y.merge(this.defaults, options) : this.defaults;
+
+ return this.engine.revive ? this.engine.revive(precompiled, options) :
+ precompiled;
+ }
+};
+
+// Copy existing namespaced properties from Y.Template to the Template function
+// if Y.Template already exists, then make the function the new Y.Template.
+// This ensures that other modules can safely add stuff to the Y.Template
+// namespace even if they're loaded before this one.
+Y.Template = Y.Template ? Y.mix(Template, Y.Template) : Template;
+
+
+}, '@VERSION@', {"requires": ["yui-base"]});