All notable changes to this project will be documented in this file. This project adheres to Semantic Versioning.
render()
now recognizes a config object argument, by @pineapplemachine.escape
functions to escape all types of values (including number
s), by @pineapplemachine.Majority of using projects don't have to worry by this being a new major version.
TLDR; if your project manipulates Writer.prototype.parse | Writer.cache
directly or uses .to_html()
, you probably have to change that code.
This release allows the internal template cache to be customised, either by disabling it completely or provide a custom strategy deciding how the cache should behave when mustache.js parses templates.
const mustache = require('mustache');
// disable caching
Mustache.templateCache = undefined;
// or use a built-in Map in modern environments
Mustache.templateCache = new Map();
Projects that wanted to customise the caching behaviour in earlier versions of mustache.js were forced to
override internal method responsible for parsing templates; Writer.prototype.parse
. In short, that was unfortunate
because there is more than caching happening in that method.
We've improved that now by introducing a first class API that only affects template caching.
The default template cache behaves as before and is still compatible with older JavaScript environments. For those who wants to provide a custom more sopisiticated caching strategy, one can do that with an object that adheres to the following requirements:
{
set(cacheKey: string, value: string): void
get(cacheKey: string): string | undefined
clear(): void
}
To stay backwards compatible with already using projects, the default exposed module format is still UMD. That means projects using mustache.js as an CommonJS, AMD or global scope module, from npm or directly from github.com can keep on doing that for now.
For those projects who would rather want to use mustache.js as an ES module, the mustache/mustache.mjs
file has to
be import
ed directly.
Below are some usage scenarios for different runtimes.
<!-- index.html -->
<script type="module">
import mustache from "https://unpkg.com/mustache@3.2.0/mustache.mjs"
console.log(mustache.render('Hello {{name}}!', { name: 'Santa' }))
// Hello Santa!
</script>
// index.mjs
import mustache from 'mustache/mustache.mjs'
console.log(mustache.render('Hello {{name}}!', { name: 'Santa' }))
// Hello Santa!
ES Module support for Node.js will be improved in the future when Conditional Exports is enabled by default rather than being behind an experimental flag.
More info in Node.js ECMAScript Modules docs.
// index.ts
import mustache from 'https://unpkg.com/mustache@3.2.0/mustache.mjs'
console.log(mustache.render('Hello {{name}}!', { name: 'Santa' }))
// Hello Santa!
We are very happy to announce a new major version of mustache.js. We want to be very careful not to break projects out in the wild, and adhering to Semantic Versioning we have therefore cut this new major version.
The changes introduced will likely not require any actions for most using projects. The things to look out for that might cause unexpected rendering results are described in the migration guide below.
A big shout out and thanks to @raymond-lam for this release! Without his contributions with code and issue triaging, this release would never have happened.
Writer.prototype.parse
to cache by tags in addition to template string, by @raymond-lam.Writer.prototype.parse
cache, by @seminaoki.tags
parameter to Mustache.render()
, by @raymond-lam.We have ensured properties of primitive types can be rendered at all times. That means Array.length
, String.length
and similar. A corner case where this could cause unexpected output follows:
View:
{
stooges: [
{ name: "Moe" },
{ name: "Larry" },
{ name: "Curly" }
]
}
Template:
{{#stooges}}
{{name}}: {{name.length}} characters
{{/stooges}}
Output with v3.0:
Moe: 3 characters
Larry: 5 characters
Curly: 5 characters
Output with v2.x:
Moe: characters
Larry: characters
Curly: characters
We have improved the templates cache to ensure custom delimiters are taken into consideration for the cache. This improvement might cause unexpected rendering behaviour for using projects actively using the custom delimiters functionality.
Previously it was possible to use Mustache.parse()
as a means to set global custom delimiters. If custom
delimiters were provided as an argument, it would affect all following calls to Mustache.render()
.
Consider the following:
const template = "[[item.title]] [[item.value]]";
mustache.parse(template, ["[[", "]]"]);
console.log(
mustache.render(template, {
item: {
title: "TEST",
value: 1
}
})
);
>> TEST 1
The above illustrates the fact that Mustache.parse()
made mustache.js cache the template without considering
the custom delimiters provided. This is no longer true.
We no longer encourage using Mustache.parse()
for this purpose, but have rather added a fourth argument to
Mustache.render()
letting you provide custom delimiters when rendering.
If you still need the pre-parse the template and use custom delimiters at the same time, ensure to provide
the custom delimiters as argument to Mustache.render()
as well.
This release is made to revert changes introduced in 2.3.1 that caused unexpected behaviour for several users.
Writer.prototype.parse
to cache by tags in addition to template string, by @raymond-lam.Writer.prototype.parse
cache, by @seminaoki.Rakefile
, by @phillipj.Mustache.parse()
return type documentation, by @bbrooks.output
argument to mustache CLI, by @wizawu.null
lookup when rendering an unescaped value, by @dasilvacontin.version
property from bower.json, by @kkirsche.undefined
or null
values, by @dasilvacontin.