I noticed in your example you mention Jexl but I would encourage you to look at JSONATA.

I built a quick demo using Mutton and JSONATA here:

https://codesandbox.io/s/jsonata-mutton-m8ury?file=/src/App.js

Example case:

{{firstName + "{{lastName}}"}}

In the above case the actual expression would end after the end quote and the second set of double braces are found. Previously, we would end the expression after the first set of double quotes was found.

What is the problem

I am using mutton's renderTemplate to evaluate various expressions with the following data object

{
  count: 3,
  data: [
    { id: 1, name: 'name1', value: 'value1' },
    { id: 2, name: 'name2', value: 'value2' },
    { id: 3, name: 'name3', value: 'value3' }, 
  ]
}

Within my expressionEvaluator, I have a JSONata function which takes the data and the expression and will parse it. Depending on the data passed, JSONata will return a value or a list of values. For example, for the expression {{data.id}} my expressionEvaluator would return a list of ids [1, 2, 3].

Running renderTemplate with the expression {{data.id}} and my expressionEvaluator works as expected and renderTemplate returns the list of ids. However, when my expression involves multiple expressions like {{data.name}}::{{data.value}}, the lists get appended together into a string.

Where this is happening

I have determined this is happening in renderCompiledTemplateSync https://github.com/austinkelleher/mutton/blob/master/src/renderCompiledTemplate.ts#L28

In this method, the compiled nodes (in this case of {{data.name}}::{{data.value}} [expression, literal, expression]) is iterating over each one, if it is an expression, running the expressionEvaluator, and then appending it to the previous renderedTemplate as part of a string.

I suppose this makes sense why {{data.id}} works as expected (returning a list of strings) because renderedTemplate is set to the result of the expressionEvaluator.

What I was expecting

If the expressionEvaluator returns an array, I would expect the renderedTemplate to return an array as well. So in this case of an expression containing two expressions evaluating to be arrays, I would expect a single array containing the each expression literal expression combination based on index.

Example code

I have made this code sample to demonstrate the issue https://codesandbox.io/s/mutton-issue-example-tpt2k?file=/src/index.js

Feature Request

I would like the user to be able to build complex templates using conditions and loops.

Examples

const data = {
  names: [
     { name: 'baz', bars: ["baz", "moo"] },
     { name: 'foo' }
  ]
};

with template:

{{ if (names.length) }}
   {{name}}
{{ endif }}

or a loop like:

{{ for (names)}
   {{name}} is a fun name
{{ endfor }}

Additionally, I'm using JSONATA for my processing engine, it could give me some REALLY cool expressions I could do like:

{{ for (names.bars) }}
  {{ this }}
{{ endfor }}

which could result in like: "baz moo".

Problem

I realize this engine doesn't always return strings, so I'm thinking if you scanned it and found those keywords you could say ok this is a string. Additionally, you could say when i find a for/if then pass the arr/obj in the params to the parser.

Alternatives

I found a parser that would like me use mutton + jsonata + mustache (LOL) to make complex string templates like this but it felt ---- odd to say the least.

https://martinholden-skillsoft.github.io/jsonata-extended/doc/module-jsonata-functions.html#~mustache

Proposed API:

import { compileTemplate, renderCompiledTemplateAsync } from 'mutton';

const compiled = compileTemplate('{{hopper}}');

const result = await renderCompiledTemplateAsync(compiled, {
  expressionEvaluator(expression) {
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve(expression);
      }, 100);
    });
  }
});

console.log(result); // hopper