mikel 0.23.0 → 0.24.0

package/README.md

@@ -620,83 +620,89 @@ const result = mikel("Hello, {{name}}!", data);
 console.log(result); // Output: "Hello, World!"
 ```
 
-### `mikel.create(template [, options])`
+### `mikel.create(options)`
 
-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.
+> Removed `template` argument in `v0.24.0`.
 
-It returns a function that you can call with the data to compile the template.
+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 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
@@ -80,9 +80,8 @@ const defaultHelpers = {
 };
 
 // @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 || {},
@@ -170,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
@@ -198,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.23.0",
+    "version": "0.24.0",
     "type": "module",
     "author": {
         "name": "Josemi Juanes",