eta

What is eta?

Eta is a fast, lightweight, and highly configurable embedded JavaScript template engine. It is designed to be simple and easy to use, while also being powerful enough to handle complex templating needs.

What are eta's main functionalities?

Basic Template Rendering

This feature allows you to render a basic template with embedded JavaScript expressions. The `render` function takes a template string and a data object, and returns the rendered string.

const eta = require('eta');
const template = 'Hello, <%= it.name %>!';
const data = { name: 'World' };
const result = eta.render(template, data);
console.log(result); // Output: Hello, World!

Template Caching

Eta supports template caching, which allows you to define and reuse templates by name. This can improve performance by avoiding the need to recompile templates on each render.

const eta = require('eta');
eta.templates.define('greeting', 'Hello, <%= it.name %>!');
const data = { name: 'World' };
const result = eta.render('greeting', data);
console.log(result); // Output: Hello, World!

Custom Filters

Eta allows you to define custom filters that can be used within templates to transform data. In this example, a custom filter `shout` is defined to convert a string to uppercase and add exclamation marks.

const eta = require('eta');
eta.configure({
  filters: {
    shout: (str) => str.toUpperCase() + '!!!'
  }
});
const template = 'Hello, <%= it.name | shout %>!';
const data = { name: 'World' };
const result = eta.render(template, data);
console.log(result); // Output: Hello, WORLD!!!

Other packages similar to eta

ejs

EJS (Embedded JavaScript) is a simple templating language that lets you generate HTML markup with plain JavaScript. It is similar to Eta in terms of syntax and functionality, but Eta is generally faster and more lightweight.

pug

Pug (formerly known as Jade) is a high-performance template engine heavily influenced by Haml. It is known for its clean and minimal syntax. Compared to Eta, Pug offers a more concise syntax but has a steeper learning curve.

handlebars

Handlebars is a popular templating engine that provides a more logic-less approach to templates. It uses a Mustache-like syntax and is known for its simplicity and ease of use. Unlike Eta, Handlebars enforces a separation of logic and presentation.

README

eta (η)

Documentation - Chat - RunKit Demo - Playground

You're viewing the source for Eta v3, which we just released! For v2, visit the old branch.

Summary

Eta is a lightweight and blazing fast embedded JS templating engine that works inside Node, Deno, and the browser. It's written in TypeScript and emphasizes great performance, configurability, and small bundle size.

🌟 Features

• 📦 0 dependencies
• 💡 Only ~3.5 KB minzipped
• ⚡️ Written in TypeScript
• ✨ Deno support (+ Node and browser)
• 🚀 Super Fast
• 🔧 Configurable
  • Plugins, custom delimiters, caching
• 🔨 Powerful
  • Precompilation, partials, async
  • Layout support!
• 🔥 Reliable
  • Better quotes/comments support
    • ex. <%= someval + "string %>" %> compiles correctly, while it fails with doT or EJS
  • Great error reporting
• ⚡️ Exports ES Modules as well as UMD
• 📝 Easy template syntax

Get Started

For more thorough documentation, visit https://eta.js.org

Install Eta

npm install eta

In the root of your project, create templates/simple.eta

Hi <%= it.name %>!

Then, in your JS file:

import { Eta } from "eta";
// import { Eta } from "https://deno.land/x/eta@v3.1.0/src/index.ts";

const eta = new Eta({ views: path.join(__dirname, "templates") });

// Render a template

const res = eta.render("./simple", { name: "Ben" });
console.log(res); // Hi Ben!

FAQs

Where did Eta's name come from?

"Eta" means tiny in Esperanto. Plus, it can be used as an acronym for all sorts of cool phrases: "ECMAScript Template Awesomeness", "Embedded Templating Alternative", etc....

Additionally, Eta is a letter of the Greek alphabet (it stands for all sorts of cool things in various mathematical fields, including efficiency) and is three letters long (perfect for a file extension).

Integrations

Visual Studio Code

@shadowtime2000 created eta-vscode.

ESLint

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

Webpack

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 });
    },
  },
}

Node-RED

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

Koa

To render Eta templates in Koa web framework: @cedx/koa-eta

Projects using eta

• Docusaurus v2: open-source documentation framework that uses Eta to generate a SSR build
• swagger-typescript-api: Open source typescript api codegenerator from Swagger. Uses Eta as codegenerator by templates
• html-bundler-webpack-plugin: Webpack plugin make easily to bundle HTML pages from templates, source styles and scripts
• SmartDeno: SmartDeno is an easy to setup web template using Deno & Oak
• stc: OpenAPI (Swagger) and Apifox documentation converted to api. Use eta templates to generate code.
• Add yours!

Contributors

Made with ❤ by @nebrelbug and all these wonderful contributors (emoji key):

Ben Gubler 💻 💬 📖 ⚠️	Clite Tailor 🤔 💻	Ioan CHIRIAC 💻 🤔	Craig Morten 💻	Rajan Tiwari 💡	shadowtime2000 💻 🤔 ⚠️	Hamza Hamidi 📖
Calum Knott 🤔	nhaef 💻	Gün 💻

This project follows the all-contributors specification. Contributions of any kind are welcome!

Credits

• Async support, file handling, and error formatting were based on code from EJS, which is licensed under the Apache-2.0 license. Code was modified and refactored to some extent.
• Syntax and some parts of compilation are heavily based off EJS, Nunjucks, and doT.