Awesome
mejs
Moduled and Embedded JavaScript templates, run in node.js and all browsers.
Features
- Run in node.js and all browsers
- Custom delimiters (e.g., use '<? ?>' instead of '<% %>')
- Full support for
include
- Full support for
import
(Moduled) - Support
layout
in server side - Support express, koa, toa ...
Tags
<%
: 'Scriptlet' tag, for control-flow, no output<%_
: 'Whitespace Slurping' Scriptlet tag, strips all whitespace before it<%=
: Outputs the value into the template (escaped)<%-
: Outputs the unescaped value into the template<%#
: Comment tag, no execution, no output<%%
: Outputs a literal '<%'%%>
: Outputs a literal '%>'%>
: Plain ending tag-%>
: Trim-mode ('newline slurp') tag, trims following newline_%>
: 'Whitespace Slurping' ending tag, removes all whitespace after it
Implementations:
Demo
Installation
npm install mejs
API
const mejsCompile = require('mejs')
mejsCompile(patternOrMejsfile[, options]) => Mejs
Class
Compile ejs templates to a Mejs
Class.
patternOrMejsfile
: Glob pattern to read template files. Ormejs
file object.options.glob
: Glob optionsoptions.base
: Everything before a glob (same as tplName) starts.options.delimiter
: Character to use with angle brackets for open/close, default is%
.options.rmWhitespace
: Remove all safe-to-remove whitespace, including leading and trailing whitespace in compiling. It also enables a safer version of-%>
line slurping for all scriptlet tags (it does not strip new lines of tags in the middle of a line).options.rmComment
: Remove comment before compiling (/<!--([\s\S]*?)-->/g
).options.rmLinefeed
: Remove linefeed and trailing whitespace before compiling (/\n+[\s]*/g
).
const Mejs = mejsCompile('views/**/*.html') // options.base == 'views/'
mejsCompile.initMejs(pattern[, options]) => mejs
object
mejs
object have renderEx
method that support layout
, it is useful in server side.
pattern
:pattern
is same as above.options
:options
is same as above, and haveoptions.locals
,options.layout
andoptions.sandbox
apply for Mejs class.
mejsCompile.initView(pattern[, options]) => View
class
It is implemented for express. arguments is same as mejsCompile.initMejs
.
const app = express()
app.set('view', mejs.initView('views/**/*.ejs', {
layout: 'layout',
locals: app.locals
}))
//... render with layout
res.render('index', {user: req.user})
//... disable layout for 'login' view
res.render('login', {layout: false})
mejsCompile.precompile(files[, options]) => mejs
file object
Precompile ejs templates to a file object, then you can write it to a JS file.
files
: Template files array, the file in array must havepath
andcontents
.options
:options
is same as above. but one more:options.mini
: Precompile a minimum templates module, it is not a Mejs class, should be imported to Mejs class byMejs.import
const mejsSource = mejsCompile.precompile([{
path: 'index.html',
contents: 'index content...'
}, {
path: 'layout.html',
contents: 'layout content...'
}, {
path: 'lib/index',
contents: 'lib index content...'
}
], {base: 'views'})
mejsCompile.precompileFromGlob(pattern[, options]) => mejs
file object
Precompile ejs teamplates to a file object, then you can write it to a JS file.
pattern
: glob pattern.options
:options
is same as above.
const mejsSource = mejsCompile.precompileFromGlob('views/**/*.js', {base: 'views'})
mejsCompile.Template(text[, options])
Ejs template engine.
mejsCompile.File(contents[, options][, base])
mejs
file Class. It is similar to vinyl, AKA gulp file
new Mejs(locals) => mejs
object
locals
: global locals object, default is{}
.
// add config, moment and node-i18n to global locals
const mejs = new Mejs({
config: {
host: 'www.mejs.com',
apiHost: 'www.mejs.com/api'
},
moment: moment,
locale: function() {
return this.locale
},
__: function() {
return this.__.apply(this, arguments)
}
})
Class Method: Mejs.import(templates)
Import templates to global from a templates module.
const Mejs = require('Mejs')
const tplsA = require('tplsA')
const tplsB = require('tplsB')
Mejs.import(tplsA).import(tplsB)
mejs.render(tplName, data) => filled view string
Render a template with data
tplName
: a full template namedata
: data object filled to template
mejs.render('index', userObj)
mejs.render('global/header', headerDate)
//...
mejs.import([namespace], mejsX)
import another mejs object object to mejs
, then mejs
will have the templates that from mejsX
.
namespace
: namespace stringmejsX
: mejs object for import
mejs.import('common', mejsA)
mejs.add(tplName, tplFn)
Add a template function to current mejs.
mejs.get(tplName)
Get a template function from current mejs.
mejs.remove(tplName)
Remove a template function from current mejs.
mejs.resolve(from, to)
Resolve template path.
mejs.escape(string)
escape
function for templates function. You can overwrite it.