mikel 0.34.0 → 0.35.1

package/README.md

@@ -837,7 +837,7 @@ console.log(mk("{{>hello}}", {name: "Susan"})); // --> "Hello, Susan!"
 
 It also exposes the following additional methods:
 
-#### `mk.use(options)`
+#### `mk.use(options | function)`
 
 > Added in `v0.19.0`.
 
@@ -856,12 +856,13 @@ mk.use({
 });
 ```
  
-When called with a **function**, the function receives the internal context of the instance, giving full access to the hooks system and all registered helpers, functions, and partials. This is the recommended approach for writing reusable plugins:
+When called with a **function**, the function receives the internal context of the instance, giving full access to all registered helpers, functions, and partials. This is the recommended approach for writing reusable plugins:
  
 ```javascript
 const myPlugin = (ctx) => {
-    ctx.hooks.add("preRender", template => template.trim());
-    ctx.hooks.add("postRender", output => output.trim());
+    ctx.helpers.uppercase = ({ fn, data }) => {
+        return fn(data).toUpperCase();
+    };
 };
  
 mk.use(myPlugin);
@@ -927,66 +928,16 @@ This function returns the value in `object` following the provided `path` string
 
 ### Built‑in Plugins
 
-> Added in `v0.34.0`.
+> Added in `v0.35.0`.
 
-Mikel includes a small set of built‑in plugins that provide common functionality without requiring additional packages. These plugins integrate directly into the compilation lifecycle and use the same hook system available to any external plugin.
+Mikel includes a small set of built‑in plugins that provide common functionality without requiring additional packages.
 
-#### `mikel.WrapperPlugin(options)`
+#### `mikel.SetStatePlugin(name, value)`
 
-Wraps the original template by inserting custom text before and/or after it. The wrapper is applied before rendering, which means it can contain mikel expressions (`{{variables}}`, helpers, etc.).
+Registers a static state variable that become available inside templates through the `@variable` syntax.
 
 ```javascript
-mk.use(mikel.WrapperPlugin({
-    header: "<!-- START -->\n",
-    footer: "\n<!-- END -->",
-}));
-```
-
-#### `mikel.StatePlugin(state)`
-
-Defines static state variables that become available inside templates through the `@variable` syntax. These values are merged into the initial state before rendering.
-
-```javascript
-mk.use(mikel.StatePlugin({
-    version: "1.0.0",
-    environment: "development",
-}));
-```
-
-### Hooks
- 
-> Added in `v0.34.0`.
- 
-Hooks allows plugins to tap into different stages of the rendering pipeline. Hooks are registered using the `hooks.add` method inside a plugin function passed to `mk.use()`.
-
-```javascript
-mk.use((context) => {
-    context.hooks.add("someHook", (params) => {
-        // ...
-    });
-});
-```
-
-Available hooks:
- 
-| Hook |  Type | Receives | Must return | Description |
-|------|-------|----------|-------------|-------------|
-| `preRender` | Waterfall | `template` (string) | `template` (string) | Called before rendering. The returned value is used as the template. |
-| `postRender` | Waterfall | `output` (string) | `output` (string) | Called after rendering. The returned value is used as the final output. |
- 
-Example:
- 
-```javascript
-const myPlugin = (context) => {
-    // trim the template before rendering
-    context.hooks.add("preRender", template => template.trim());
-    // minify the output after rendering
-    context.hooks.add("postRender", output => output.replace(/\s+/g, " ").trim());
-};
- 
-mk.use(myPlugin);
- 
-console.log(mk("  Hello {{name}}!  ", { name: "World" })); // --> "Hello World!"
+mk.use(mikel.SetStatePlugin("version", "1.0.0"));
 ```
 
 ## License

package/index.d.ts

@@ -40,11 +40,6 @@ export type MikelContext = {
     helpers: Record<string, MikelFunction>;
     functions: Record<string, MikelFunction>;
     partials: Record<string, MikelPartial>;
-    hooks: {
-        add: (hookName: string, listener: Function) => void;
-        call: (hookName: string, ...args: any[]) => void;
-        callWaterfall: (hookName: string, value: any) => any;
-    };
     initialState: MikelState;
 };
 
@@ -61,8 +56,7 @@ export type Mikel = {
     removePartial(name: string): void;
 };
 
-export type MikelWrapperPlugin = (options: { header?: string, footer?: string }) => MikelPlugin;
-export type MikelStatePlugin = (state: MikelState) => MikelPlugin;
+export type MikelSetStatePlugin = (name: string, value: any) => MikelPlugin;
 
 declare const mikel: {
     (template: string, data?: any, options?: Partial<MikelOptions>): string;
@@ -72,8 +66,7 @@ declare const mikel: {
     parse(value: string, context?: any, vars?: any): any;
     tokenize(str: string): string[];
     untokenize(tokens: string[], start?: string, end?: string): string;
-    WrapperPlugin: MikelWrapperPlugin;
-    StatePlugin: MikelStatePlugin;
+    SetStatePlugin: MikelSetStatePlugin;
 };
 
 export default mikel;

package/index.js

@@ -122,24 +122,6 @@ const findClosingToken = (tokens, i, token) => {
     throw new Error(`Unmatched section end: {{${token}}}`);
 };
 
-// @description create a hook manager for the provided hooks map
-const createHookManager = (hooks = new Map()) => {
-    return {
-        add: (hookName, listener) => {
-            if (!hooks.has(hookName.toLowerCase())) {
-                hooks.set(hookName.toLowerCase(), []);
-            }
-            hooks.get(hookName.toLowerCase()).push(listener);
-        },
-        call: (hookName, ...args) => {
-            hooks.get(hookName.toLowerCase())?.forEach((listener) => listener(...args));
-        },
-        callWaterfall: (hookName, value) => {
-            return (hooks.get(hookName.toLowerCase()) || []).reduce((v, listener) => listener(v), value);
-        },
-    };
-};
-
 // @description internal method to compile the template
 const compile = (ctx, tokens, output, data, state, index = 0, section = "") => {
     let i = index;
@@ -296,14 +278,12 @@ const create = (options = {}) => {
         partials: Object.assign({}, options?.partials || {}),
         functions: Object.assign({}, options?.functions || {}),
         initialState: {}, // Object.assign({}, options?.initialState || {}),
-        hooks: createHookManager(new Map()),
     });
     // entry method to compile the template with the provided data object
-    const compileTemplate = (originalTemplate, data = {}) => {
+    const compileTemplate = (template, data = {}) => {
         const output = [];
-        const template = ctx.hooks.callWaterfall("prerender", originalTemplate || "");
         compile(ctx, tokenize(template), output, data, { ...ctx.initialState, root: data }, 0, "");
-        return ctx.hooks.callWaterfall("postrender", output.join(""));
+        return output.join("");
     };
     // assign api methods and return method to compile the template
     return Object.assign(compileTemplate, {
@@ -331,19 +311,10 @@ const mikel = (template = "", data = {}, options = {}) => {
     return create(options)(template, data);
 };
 
-// @description plugin to wrap template with custom text
-mikel.WrapperPlugin = (options = {}) => {
-    return (context) => {
-        context.hooks.add("prerender", template => {
-            return [options.header || "", template, options.footer || ""].join("");
-        });
-    };
-};
-
-// @description plugin to define state variables
-mikel.StatePlugin = (state = {}) => {
+// @description plugin to define a new state variable
+mikel.SetStatePlugin = (name, value) => {
     return (context) => {
-        Object.assign(context.initialState, state || {});
+        context.initialState[name] = value;
     };
 };
 

package/package.json

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