mikel 0.27.1 → 0.29.0

package/README.md

@@ -112,13 +112,6 @@ const result = m("{{> hello}}", data, {partials});
 // Output: 'Hello Bob!'
 ```
 
-Partial metadata can be accessed using the `@partial` variable inside the partial. It contains the following fields:
-
-- `name`: the name of the partial being rendered.
-- `args`: an array containing the positional arguments provided to the partial (if any). See the **Custom context in partials** section for more details.
-- `opt`: an object containing the keyword arguments provided to the partial (if any). See the **Keyword arguments in partials** section for more details.
-- `attributes`: the custom data provided to the partial (if any). See the **Partials data** section for more details.
-
 #### Custom context in partials
 
 > This feature was added in `v0.3.1`.
@@ -232,6 +225,31 @@ const result = m("{{>foo}}", {}, options);
 // Output: 'Hello Bob!'
 ```
 
+#### Accessing to partial metadata using the `@partial` variable
+
+> Added in `v0.28.0`.
+
+Partial metadata can be accessed using the `@partial` variable inside the partial. It contains the following fields:
+
+- `@partial.name`: the name of the partial being rendered.
+- `@partial.args`: an array containing the positional arguments provided to the partial (if any).
+- `@partial.options`: an object containing the keyword arguments provided to the partial (if any).
+- `@partial.attributes`: the custom data provided to the partial (if any).
+- `@partial.context`: the current rendering context.
+
+### Inline partials
+
+> Added in `v0.28.0`.
+
+Inline partials allows you to define partials directly in your template. Use `>*` followed by the partial name to start the partial definition, and end the partial definition with a slash `/` followed by the partial name. For example, `{{>*foo}}` begins a partial definition called `foo`, and `{{/foo}}` ends it.
+
+Example:
+
+```javascript
+const result = m(`{{>*foo}}Hello {{name}}!{{/foo}}{{>foo name="Bob"}}`, {});
+// Output: 'Hello Bob!'
+```
+
 ### Helpers
 
 > Added in `v0.4.0`.
@@ -415,10 +433,10 @@ const result = m(template, data, options);
 console.log(result); // Output: "Hello, World!"
 ```
 
-Custom helper functions receive a single object as argument, containing the following keys:
+Custom helper functions receive a single `params` object as argument, containing the following fields:
 
 - `args`: an array containing the variables with the helper is called in the template.
-- `opt`: an object containing the keyword arguments provided to the helper.
+- `options`: an object containing the keyword arguments provided to the helper.
 - `data`: the current data where the helper has been executed.
 - `variables`: an object containing the runtime variables available in the current context (e.g., `@root`, `@index`, etc.).
 - `fn`: a function that executes the template provided in the helper block and returns a string with the evaluated template in the provided context.
@@ -447,7 +465,7 @@ console.log(result); // --> "0: John, 1: Alice, 2: Bob,"
 
 #### Expand helper arguments using the spread operator
 
-> This feature was addedin `v0.20.0`.
+> This feature was added in `v0.20.0`.
 
 You can use the spread operator `...` to expand the arguments of a helper. This allows you to pass an array of values as individual arguments to the helper, or to pass an object as keyword arguments.
 
@@ -472,6 +490,17 @@ const result = m("{{#join ...items ...options}}{{/join}}", data, options);
 console.log(result); // --> "John, Alice, Bob"
 ```
 
+#### Accessing to helper metadata using the `@helper` variable
+
+> Introduced in `v0.28.0`.
+
+Inside any helper block, you can access metadata about the current invocation through the `@helper` variable. It exposes the following fields:
+
+- `@helper.name`: the name of the helper being invoked.
+- `@helper.args`: an array of positional arguments passed to the helper.
+- `@helper.options`: an object containing named (key-value) arguments.
+- `@helper.context`: the current rendering context.
+
 ### Runtime Variables
 
 > Added in `v0.4.0`.
@@ -533,10 +562,10 @@ Mikel allows users to define custom functions that can be used within templates
 
 Functions should be provided in the `options.functions` field of the options object when rendering a template. Each function is defined by a name and a corresponding function that performs the desired operation.
 
-Functions will receive a single object as argument, containing the following keys:
+Functions will receive a single `params` object as argument, containing the following keys:
 
 - `args`: an array containing the variables with the function is called in the template.
-- `opt`: an object containing the keyword arguments provided to the function.
+- `options`: an object containing the keyword arguments provided to the function.
 - `data`: the current data object where the function has been executed.
 - `variables`: an object containing the runtime variables available in the current context (e.g., `@root`, `@index`, etc.).
 
@@ -603,7 +632,7 @@ const data = {
 const options = {
     functions: {
         fullName: params => {
-            return `${params.opt.firstName} ${params.opt.lastName}`;
+            return `${params.options.firstName} ${params.options.lastName}`;
         }
     },
 };

package/index.d.ts

@@ -1,6 +1,7 @@
 export type MikelHelper = (params: {
     args: any[];
-    opt: Record<string, any>;
+    opt?: Record<string, any>;
+    options: Record<string, any>;
     tokens: string[];
     data: Record<string, any>;
     variables: Record<string, any>;
@@ -14,7 +15,8 @@ export type MikelPartial = {
 
 export type MikelFunction = (params: {
     args: any[];
-    opt: Record<string, any>;
+    opt?: Record<string, any>;
+    options: Record<string,any>;
     data: Record<string, any>;
     variables: Record<string, any>;
 }) => string | void;

package/index.js

@@ -75,9 +75,17 @@ const findClosingToken = (tokens, i, token) => {
 const defaultHelpers = {
     "each": p => {
         const items = typeof p.args[0] === "object" ? Object.entries(p.args[0] || {}) : [];
-        const limit = Math.min(items.length - (p.opt.skip || 0), p.opt.limit || items.length);
-        return items.slice(p.opt.skip || 0, (p.opt.skip || 0) + limit)
-            .map((item, index) => p.fn(item[1], {index: index, key: item[0], value: item[1], first: index === 0, last: index === items.length - 1}))
+        const limit = Math.min(items.length - (p.options?.skip || 0), p.options?.limit || items.length);
+        return items.slice(p.options?.skip || 0, (p.options?.skip || 0) + limit)
+            .map((item, index) => {
+                return p.fn(item[1], {
+                    index: index, 
+                    key: item[0],
+                    value: item[1],
+                    first: index === 0,
+                    last: index === items.length - 1,
+                });
+            })
             .join("");
     },
     "if": p => !!p.args[0] ? p.fn(p.data) : "",
@@ -110,12 +118,25 @@ const create = (options = {}) => {
                 i = findClosingToken(tokens, j, t);
                 output.push(ctx.helpers[t]({
                     args: args,
-                    opt: opt,
+                    opt: opt, // deprecated
+                    options: opt,
                     tokens: tokens.slice(j, i),
                     data: data,
                     variables: vars,
                     fn: (blockData = {}, blockVars = {}, blockOutput = []) => {
-                        compile(tokens, blockOutput, blockData, {...vars, ...blockVars, parent: data, root: vars.root}, j, t);
+                        const helperVars = {
+                            ...vars,
+                            ...blockVars,
+                            helper: {
+                                name: t,
+                                options: opt || {},
+                                args: args || [],
+                                context: blockData,
+                            },
+                            parent: data,
+                            root: vars.root,
+                        };
+                        compile(tokens, blockOutput, blockData, helperVars, j, t);
                         return blockOutput.join("");
                     },
                 }));
@@ -135,6 +156,16 @@ const create = (options = {}) => {
                     i = compile(tokens, includeOutput ? output : [], data, vars, i + 1, t);
                 }
             }
+            else if (tokens[i].startsWith(">*")) {
+                const t = tokens[i].slice(2).trim(), partialTokens = tokens.slice(i + 1);
+                const lastIndex = partialTokens.findIndex((token, j) => {
+                    return j % 2 !== 0 && token.trim().startsWith("/") && token.trim().endsWith(t);
+                });
+                if (typeof ctx.partials[t] === "undefined") {
+                    ctx.partials[t] = untokenize(partialTokens.slice(0, lastIndex));
+                }
+                i = i + lastIndex + 1;
+            }
             else if (tokens[i].startsWith(">")) {
                 const [t, args, opt] = parseArgs(tokens[i].replace(/^>{1,2}/, ""), data, vars);
                 const blockContent = []; // to store partial block content
@@ -150,7 +181,8 @@ const create = (options = {}) => {
                             name: t,
                             attributes: ctx.partials[t]?.attributes || ctx.partials[t]?.data || {},
                             args: args || [],
-                            opt: opt || {},
+                            options: opt || {},
+                            context: newData,
                         },
                     };
                     compile(tokenize(ctx.partials[t]?.body || ctx.partials[t]), output, newData, newVars, 0, "");
@@ -159,7 +191,7 @@ const create = (options = {}) => {
             else if (tokens[i].startsWith("=")) {
                 const [t, args, opt] = parseArgs(tokens[i].slice(1), data, vars);
                 if (typeof ctx.functions[t] === "function") {
-                    output.push(ctx.functions[t]({args, opt, data, variables: vars}) || "");
+                    output.push(ctx.functions[t]({args, opt, options: opt, data, variables: vars}) || "");
                 }
             }
             else if (tokens[i].startsWith("/")) {

package/package.json

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