mikel 0.22.2 → 0.24.0

package/README.md

@@ -360,6 +360,16 @@ The `escape` helper allows to escape the provided block content.
 console.log(m("{{#escape}}<b>Hello World!</b>{{/escape}}")); // --> '&lt;b&gt;Hello World!&lt;/b&gt;
 ```
 
+#### raw
+
+> Added in `v0.23.0`.
+
+The `raw` helper allows to render the content of the block without evaluating it. All the stuff inside the block will be rendered as is, without processing any variables or helpers.
+
+```javascript
+console.log(m("{{#raw}}Hello {{name}}!{{/raw}}", {name: "Bob"})); // --> 'Hello {{name}}!'
+```
+
 ### Custom Helpers
 
 > Added in `v0.5.0`.
@@ -610,83 +620,89 @@ const result = mikel("Hello, {{name}}!", data);
 console.log(result); // Output: "Hello, World!"
 ```
 
-### `mikel.create(template [, options])`
+### `mikel.create(options)`
+
+> Removed `template` argument in `v0.24.0`.
 
-Allows to create an isolated instance of mikel, useful when you want to compile the same template using different data. The `template` argument is the template string, and the optional `options` argument is the same options object that you can pass to `mikel` method.
+Allows to create an isolated instance of mikel, useful when you want to use the same options for multiple templates without passing them every time. You can pass an `options` object with the same structure as the one used in the `mikel` function, which will be used for all templates compiled with this instance.
 
-It returns a function that you can call with the data to compile the template.
+It returns a function that you can call with the template and data to compile the template.
 
 ```javascript
 import mikel from "mikel";
 
-const template = mikel.create("Hello, {{name}}!");
+const mk = mikel.create({
+    partials: {
+        hello: "Hello, {{name}}!",
+    },
+});
 
-console.log(template({name: "Bob"})); // --> "Hello, Bob!"
-console.log(template({name: "Susan"})); // --> "Hello, Susan!"
+console.log(mk("{{>hello}}", {name: "Bob"})); // --> "Hello, Bob!"
+console.log(mk("{{>hello}}", {name: "Susan"})); // --> "Hello, Susan!"
 ```
 
 It also exposes the following additional methods:
 
-#### `template.use(options)`
+#### `mk.use(options)`
 
 > Added in `v0.19.0`.
 
 Allows to extend the templating with custom **helpers**, **functions**, and **partials**.
 
 ```javascript
-template.use({
+mk.use({
     partials: {
         foo: "bar",
     },
 });
 ```
 
-#### `template.addHelper(helperName, helperFn)`
+#### `mk.addHelper(helperName, helperFn)`
 
 Allows to register a new helper instead of using the `options` object.
 
 ```javascript
-template.addHelper("foo", () => { ... });
+mk.addHelper("foo", () => { ... });
 ```
 
-#### `template.removeHelper(helperName)`
+#### `mk.removeHelper(helperName)`
 
 Removes a previously added helper.
 
 ```javascript
-template.removeHelper("foo");
+mk.removeHelper("foo");
 ```
 
-#### `template.addPartial(partialName, partialCode)`
+#### `mk.addPartial(partialName, partialCode)`
 
 Registers a new partial instead of using the `options` object.
 
 ```javascript
-template.addPartial("bar", " ... ");
+mk.addPartial("bar", " ... ");
 ```
 
-#### `template.removePartial(partialName)`
+#### `mk.removePartial(partialName)`
 
 Removes a previously added partial.
 
 ```javascript
-template.removePartial("bar");
+mk.removePartial("bar");
 ```
 
-#### `template.addFunction(fnName, fn)`
+#### `mk.addFunction(fnName, fn)`
 
 Registers a new function instead of using the `options` object.
 
 ```javascript
-template.addFunction("foo", () => "...");
+mk.addFunction("foo", () => "...");
 ```
 
-#### `template.removeFunction(fnName)`
+#### `mk.removeFunction(fnName)`
 
 Removes a previously added function.
 
 ```javascript
-template.removeFunction("foo");
+mk.removeFunction("foo");
 ```
 
 ### `mikel.escape(str)`

package/index.d.ts

@@ -33,8 +33,8 @@ declare interface MikelOptions {
     variables?: Variables;
 }
 
-declare interface MikelTemplate {
-    (data?: any): string;
+declare interface MikelInstance {
+    (template: string, data?: any): string;
     use(options: Partial<MikelOptions>): MikelTemplate;
     addHelper(name: string, fn: HelperFunction): void;
     removeHelper(name: string): void;
@@ -46,7 +46,7 @@ declare interface MikelTemplate {
 
 declare const mikel: {
     (template: string, data?: any, options?: Partial<MikelOptions>): string;
-    create(template: string, options?: Partial<MikelOptions>): MikelTemplate;
+    create(options?: Partial<MikelOptions>): MikelInstance;
     escape(str: string): string;
     get(context: any, path: string): any;
     parse(value: string, context?: any, vars?: any): any;

package/index.js

@@ -13,7 +13,7 @@ const get = (c, p) => (p === "." ? c : p.split(".").reduce((x, k) => x?.[k], c))
 // @description tokenize and untokenize methods
 const tokenize = (str = "") => str.split(/\{\{|\}\}/);
 const untokenize = (ts = [], s = "{{", e = "}}") => {
-    return ts.reduce((p, t, i) => p + (i % 2 === 0 ? e : s) + t);
+    return ts.length > 0 ? ts.reduce((p, t, i) => p + (i % 2 === 0 ? e : s) + t) : "";
 };
 
 // @description parse string arguments
@@ -45,6 +45,22 @@ const parse = (v, data = {}, vars = {}) => {
     return (v || "").startsWith("@") ? get(vars, v.slice(1)) : get(data, v || ".");
 };
 
+// @description find the index of the closing token
+const findClosingToken = (tokens, i, token) => {
+    while(i < tokens.length) {
+        if (i % 2 > 0) {
+            if (tokens[i].startsWith("/") && tokens[i].slice(1).trim() === token) {
+                return i;
+            }
+            else if (tokens[i].startsWith("#") && tokens[i].slice(1).trim().split(" ")[0] === token) {
+                i = findClosingToken(tokens, i + 1, token);
+            }
+        }
+        i = i + 1;
+    }
+    throw new Error(`Unmatched section end: {{${token}}}`);
+};
+
 // @description default helpers
 const defaultHelpers = {
     "each": p => {
@@ -60,12 +76,12 @@ const defaultHelpers = {
     "ne": p => p.args[0] !== p.args[1] ? p.fn(p.data) : "",
     "with": p => p.fn(p.args[0]),
     "escape": p => escape(p.fn(p.data)),
+    "raw": p => untokenize(p.tokens),
 };
 
 // @description create a new instance of mikel
-const create = (template = "", options = {}) => {
+const create = (options = {}) => {
     const ctx = {
-        tokens: tokenize(template),
         helpers: Object.assign({}, defaultHelpers, options?.helpers || {}),
         partials: Object.assign({}, options?.partials || {}),
         functions: options?.functions || {},
@@ -81,20 +97,18 @@ const create = (template = "", options = {}) => {
             else if (tokens[i].startsWith("#") && typeof ctx.helpers[tokens[i].slice(1).trim().split(" ")[0]] === "function") {
                 const [t, args, opt] = parseArgs(tokens[i].slice(1), data, vars);
                 const j = i + 1;
+                i = findClosingToken(tokens, j, t);
                 output.push(ctx.helpers[t]({
                     args: args,
                     opt: opt,
+                    tokens: tokens.slice(j, i),
                     data: data,
                     variables: vars,
                     fn: (blockData = {}, blockVars = {}, blockOutput = []) => {
-                        i = compile(tokens, blockOutput, blockData, {...vars, ...blockVars, parent: data, root: vars.root}, j, t);
+                        compile(tokens, blockOutput, blockData, {...vars, ...blockVars, parent: data, root: vars.root}, j, t);
                         return blockOutput.join("");
                     },
                 }));
-                // Make sure that this block is executed at least once
-                if (i + 1 === j) {
-                    i = compile(tokens, [], {}, {}, j, t);
-                }
             }
             else if (tokens[i].startsWith("#") || tokens[i].startsWith("^")) {
                 const t = tokens[i].slice(1).trim();
@@ -155,8 +169,8 @@ const create = (template = "", options = {}) => {
         return i;
     };
     // entry method to compile the template with the provided data object
-    const compileTemplate = (data = {}, output = []) => {
-        compile(ctx.tokens, output, data, {root: data, ...ctx.variables}, 0, "");
+    const compileTemplate = (template, data = {}, output = []) => {
+        compile(tokenize(template), output, data, {root: data, ...ctx.variables}, 0, "");
         return output.join("");
     };
     // assign api methods and return method to compile the template
@@ -183,7 +197,7 @@ const create = (template = "", options = {}) => {
 
 // @description main compiler function
 const mikel = (template = "", data = {}, options = {}) => {
-    return create(template, options)(data);
+    return create(options)(template, data);
 };
 
 // @description assign utilities

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mikel",
     "description": "Micro templating library with zero dependencies",
-    "version": "0.22.2",
+    "version": "0.24.0",
     "type": "module",
     "author": {
         "name": "Josemi Juanes",