eta (η)

Eta’s syntax is very similar to EJS’ (most templates should work with either engine), Eta has a similar API, and Eta and EJS share the same file-handling logic. Here are the differences between Eta and EJS:

• Eta is more lightweight. Eta weighs less than 2.5KB gzipped, while EJS is 4.4KB gzipped
• Eta compiles and renders templates much faster than EJS. Check out these benchmarks: https://rawgit.com/eta-dev/eta/master/browser-tests/benchmark.html
• Eta allows left whitespace control (with -), something that doesn’t work in EJS because EJS uses - on the left side to indicate that the value shouldn’t be escaped. Instead, Eta uses ~ to output a raw value
• Eta gives you more flexibility with delimeters – you could set them to {{ and }}, for example, while with EJS this isn’t possible
• Eta adds plugin support
• Comments in Eta use /* ... */ which allows commenting around template tags
• Eta parses strings correctly. Example: <%= "%>" %> works in Eta, while it breaks in EJS
• Eta exposes Typescript types and distributes a UMD build
• Eta supports custom tag-type indicators. Example: you could change <%= to <%*

Eta and doT.js both allow embedded JavaScript, and both have best-in-class performance when compared to other template engines (though Eta is slightly faster with HTML-escaped templates). Here are some of the differences between Eta and doT.js:

• Eta allows you to control how you strip preceding and trailing whitespace after tags.
• It’s much simpler to set custom delimiters with Eta than doT – you don’t have to rewrite every configuration Regular Expression
• Eta supports plugins
• Eta supports async
• Eta parses strings and multi-line comments correctly. Example: <%= "%>" %> works in Eta, while the equivalent breaks in doT
• Eta exposes Typescript types and distributes a UMD build
• Eta supports runtime partials and file-handling.

Eta and Handlebars are very different in some ways – Eta is an embedded template engine, while Handlebars is a logic-less template engine. Here some additional differences between Eta and Handlebars:

• Eta is more lightweight. Eta weighs less than 2.5KB gzipped, while Handlebars is ~22KB gzipped
• Eta compiles and renders templates much faster than Handlebars – around 7x faster. Check out these benchmarks: https://ghcdn.rawgit.org/eta-dev/eta/master/browser-tests/benchmark.html
• Eta allows you to set custom delimiters
• Eta supports plugins
• Eta exposes Typescript types and distributes a UMD build
• Custom tag-type indicators. Example: you could change <%= to <%*
• With Eta, you don’t need to register tons of helpers to do simple tasks like check if one value equals another value
• Note that Eta templates run as trusted code – just like any other JavaScript you write.
  
  If you are running user-defined/created templates on your machine, server, site, etc., you probably should go with a tool built for that purpose, like Handlebars.

Template literals are a super useful tool, especially for shortening simple string concatenation. But writing complete templates using template literals can quickly get out of hand. Here’s a comparison of Eta and template literals:

• Eta compiles templates into JavaScript functions that use string concatenation and have comparable performance with template literals
• Eta lets you control preceding and trailing whitespace around tags
• Eta gives you more flexibility with delimeters – you could set them to {{ and }}, for example, or set them to ${ and } to mimic template literals
• Eta supports plugins
• Eta supports comments with /* ... */ syntax, just like in regular JavaScript. Template literals require you to stick a blank string after the comment: /* ... */"", which is much less readable
• To write conditionals inside template literals, you have to use the ternary operator. Add more conditions or nested conditionals, and it quickly becomes a nightmarish mess of ? ... : ... ? ... : .... Writing conditionals in Eta is much simpler and more readable
• Eta supports partials

@shadowtime2000 created eta-vscode.

eslint-plugin-eta was created to provide an ESLint processor so you can lint your Eta templates.

An official Eta CLI exists called etajs-cli.

Currently there is no official Webpack integration but @clshortfuse shared the loader he uses:

{
  loader: 'html-loader',
  options: {
    preprocessor(content, loaderContext) {
      return eta.render(content, {}, { filename: loaderContext.resourcePath });
    },
  },
}

To operate with Eta templates in Node-RED: @ralphwetzel/node-red-contrib-eta