TypeScript handlebars.compile函数代码示例

	private populateTemplate(mailData: Mailer): Promise<Mailer> {
		let deferred = Q.defer();
		mailData.message = Handlebars.compile(mailData.template.html)(mailData.templateData);
		mailData.template.subject = Handlebars.compile(mailData.template.subject)(mailData.templateData);
		deferred.resolve(mailData);
		return deferred.promise;
	}

  getTemplateFunction() {
    // Template compilation
    // --------------------

    // This demo uses Handlebars templates to render views.
    // The template is loaded with Require.JS and stored as string on
    // the view prototype. On rendering, it is compiled on the
    // client-side. The compiled template function replaces the string
    // on the view prototype.
    //
    // In the end you might want to precompile the templates to JavaScript
    // functions on the server-side and just load the JavaScript code.
    // Several precompilers create a global JST hash which stores the
    // template functions. You can get the function by the template name:
    //
    // templateFunc = JST[@templateName];
    let template = this.template;
    let templateFunction: Function;

    if (typeof template === 'string') {
      // Compile the template string to a function and save it
      // on the prototype. This is a workaround since an instance
      // shouldn't change its prototype normally.

      templateFunction = Handlebars.compile(template);
      this.template = templateFunction;
    } else if (typeof template === 'function') {
      templateFunction = template;
    }

    return templateFunction;
  }

function exportTexturePoolViaHandlebarsTemplate(
  folderRootTo: string,
  templateFolderAndFile: string,
  data: any,
) {
  let text = fs.readFileSync(templateFolderAndFile, 'utf8');
  if (text && text.length > 0) {
    text = text.replace(/\r/g, '');

    const lines = text.split('\n');
    if (lines.length > 1 && lines[0]) {
      const resultFile = path.resolve(folderRootTo, lines[0]);
      text = lines.slice(1).join('\n');

      console.log(`${templateFolderAndFile} => ${resultFile}`);
      const template = handlebars.compile(text);
      if (template) {
        fs.ensureDirSync(path.dirname(resultFile));
        fs.writeFileSync(resultFile, template(data));
      } else {
        console.log('template error in ' + resultFile);
      }
    }
  }
}

Marionette.TemplateCache.prototype.compileTemplate = (rawTemplate: any): any => {
  if (_.isFunction(rawTemplate)) {
    return rawTemplate;
  } else {
    return Handlebars.compile(rawTemplate);
  }
};

    private _compileTemplate(templatePath: string, data: Object) {
        const templateFileName = path.join(process.cwd(), templatePath);
        const templateFile = fs.readFileSync(templateFileName, 'UTF-8');

        const templateFunc: Function = handlebars.compile(templateFile);
        return templateFunc(data);
    }

        .then((data) => {
            const [file, pack, meta] = data;
            const connectionTypes = ['mainnet', 'testnet'];

            if (!param.scripts) {
                const sourceFiles = getFilesFrom(join(__dirname, '../src'), '.js', function (name, path) {
                    return !name.includes('.spec') && !path.includes('/test/');
                });
                param.scripts = meta.vendors.map((i) => join(__dirname, '..', i)).concat(sourceFiles);
                param.scripts.push(join(__dirname, '../loginDaemon.js'));
            }

            if (!param.styles) {
                param.styles = meta.stylesheets.map((i) => join(__dirname, '..', i)).concat(getFilesFrom(join(__dirname, '../src'), '.less'));
            }

            const networks = connectionTypes.reduce((result, item) => {
                result[item] = meta.configurations[item];
                return result;
            }, Object.create(null));

            return compile(file)({
                pack: pack,
                domain: meta.domain,
                build: {
                    type: 'web'
                },
                network: networks[param.connection]
            });
        })

        handler: function(request, reply) {
            let paths = getPaths(server, baseUri, filter);
            let source = fs.readFileSync(__dirname + '/sitemap.xml.hbs', 'utf8');

            let template = handlebars.compile(source);
            reply(template({paths: paths}))
                .type('application/xml');
        },

function subHandle(fullPath: string, args: any) {
  wd = path.dirname(fullPath);
  let tmpl = fs.readFileSync(fullPath, 'utf8');

  var template = hbs.compile(tmpl.toString());
  var result = template(args);
  return result;
}

export function loadTemplate(name: string): Template {

  const template = handlebars.compile(
    fs.readFileSync(__dirname + '/../templates/' + name + '.hbs', 'utf-8')
  );

  return template;

}

      tmpl: function(resolver, templateString, refObj, wire) {
        var template = handlebars.compile(templateString);

        // get the entire wire context
        wire.createChild({}).
          // render the template with the context
          then(template).
          // resolve with the rendered template
          then(resolver.resolve).
          catch(resolver.reject);
      }