@peter.naydenov/morph 3.1.4 → 3.1.5

package/Changelog.md

@@ -2,6 +2,11 @@
 
 
 
+### 3.1.5 (2025-11-14)
+- [x] Types improvements;
+
+
+
 ### 3.1.4 (2025-10-13)
 - [x] Dependencies update. Dev deps update. @peter.naydenov/walk - v.5.0.2;
 

package/dist/main.d.ts

@@ -0,0 +1,100 @@
+export default morphAPI;
+declare namespace morphAPI {
+    export { build };
+    export { get };
+    export { add };
+    export { list };
+    export { clear };
+    export { remove };
+}
+import build from "./methods/build.js";
+/**
+ * Retrieves a template from storage.
+ *
+ * @param {string[]} location - The location of the template. Array of two elements:
+ *   - First element: The name of the template
+ *   - Second element (optional): The name of the storage. Defaults to 'default'
+ *
+ * @returns {Function} The template (render function) if found, or an error function that returns
+ *   an error message if the storage or template doesn't exist.
+ *
+ * @example
+ * // Get template from default storage
+ * const template = get(['myTemplate']);
+ *
+ * @example
+ * // Get template from custom storage
+ * const template = get(['myTemplate', 'customStorage']);
+ */
+declare function get(location: string[]): Function;
+/**
+ * Adds a template to storage.
+ *
+ * If the template is already a function, it's added directly to storage.
+ * If it's a template description object, it's built first and then added.
+ * If the template is null or broken, a warning/error is logged and it's not added.
+ *
+ * @param {string[]} location - The location to add the template to. Array of two elements:
+ *   - First element: The name of the template
+ *   - Second element (optional): The name of the storage. Defaults to 'default'
+ * @param {object|function|null} tplfn - The template description object, pre-built template function, or null
+ * @param {...any} args - Additional arguments passed to the build function (only used when tplfn is a template description)
+ *
+ * @example
+ * // Add a pre-built template function
+ * add(['myTemplate'], templateFunction);
+ *
+ * @example
+ * // Add and build a template description
+ * add(['myTemplate'], {
+ *   template: 'Hello {{name}}!',
+ *   helpers: { name: (data) => data.data.name }
+ * });
+ */
+declare function add(location: string[], tplfn: object | Function | null, ...args: any[]): void;
+/**
+ * Returns an array of template names from specified storages.
+ *
+ * @param {string[]} [storageNames=['default']] - Array of storage names to retrieve template names from.
+ *   Defaults to ['default'] if not provided.
+ *
+ * @returns {string[]} Array of all template names from the specified storages.
+ *
+ * @example
+ * // List templates from default storage
+ * const templates = list();
+ *
+ * @example
+ * // List templates from multiple storages
+ * const templates = list(['default', 'customStorage']);
+ */
+declare function list(storageNames?: string[]): string[];
+/**
+ * Clears all templates from all storages.
+ *
+ * Deletes all custom storages and resets the 'default' storage to an empty object.
+ *
+ * @example
+ * // Clear all templates
+ * clear();
+ */
+declare function clear(): void;
+/**
+ * Removes a template from storage.
+ *
+ * @param {string[]} location - The location of the template to remove. Array of two elements:
+ *   - First element: The name of the template
+ *   - Second element (optional): The name of the storage. Defaults to 'default'
+ *
+ * @returns {void|string} Returns an error message if the storage or template doesn't exist,
+ *   otherwise returns undefined.
+ *
+ * @example
+ * // Remove template from default storage
+ * remove(['myTemplate']);
+ *
+ * @example
+ * // Remove template from custom storage
+ * remove(['myTemplate', 'customStorage']);
+ */
+declare function remove(location: string[]): void | string;

package/dist/methods/_actionSupply.d.ts

@@ -0,0 +1,18 @@
+export default _actionSupply;
+/**
+ * Generator function that supplies actions in a controlled sequence using a stack.
+ *
+ * Manages the flow of actions through different processing levels, allowing for
+ * dynamic action insertion during processing.
+ *
+ * @param {Object} act - Object containing action arrays organized by level
+ * @param {number} level - Maximum processing level
+ * @returns {Generator} Generator that yields action objects in sequence
+ *
+ * @example
+ * const generator = _actionSupply(actionSetup, 2);
+ * for (const action of generator) {
+ *   // Process each action
+ * }
+ */
+declare function _actionSupply(act: any, level: number): Generator;

package/dist/methods/_chopTemplates.d.ts

@@ -0,0 +1,22 @@
+export default _chopTemplate;
+/**
+ * Creates a template chopping function that splits text into parts and placeholders.
+ *
+ * @param {object} settings - Configuration object containing template delimiters
+ * @param {string} settings.TG_PRX - Opening delimiter (e.g., '{{')
+ * @param {string} settings.TG_SFX - Closing delimiter (e.g., '}}')
+ * @param {number} settings.TG_SIZE_P - Length of opening delimiter
+ * @param {number} settings.TG_SIZE_S - Length of closing delimiter
+ *
+ * @returns {Function} Function that chops template text into array parts
+ *
+ * @example
+ * const chop = _chopTemplate(settings);
+ * const result = chop('Hello {{name}}!');
+ */
+declare function _chopTemplate(settings: {
+    TG_PRX: string;
+    TG_SFX: string;
+    TG_SIZE_P: number;
+    TG_SIZE_S: number;
+}): Function;

package/dist/methods/_defineData.d.ts

@@ -0,0 +1,25 @@
+export default _defineData;
+/**
+ * Processes data source based on action requirements and creates nested data structure.
+ *
+ * Analyzes the data source and action to determine if nested data processing is needed.
+ * If action contains '#', it walks through the data structure to collect nested objects.
+ *
+ * @param {any} dSource - The data source to process (function, null, string, or object)
+ * @param {string} action - Action string that may contain '#' indicating nested processing
+ *
+ * @returns {object} Data processing result containing:
+ *   - dataDeepLevel: Maximum nesting level found
+ *   - nestedData: Array of nested data arrays organized by level
+ *
+ * @example
+ * // Simple data without nesting
+ * const result = _defineData('hello', 'render');
+ * // Returns: { dataDeepLevel: 0, nestedData: [['hello']] }
+ *
+ * @example
+ * // Nested data with '#' action
+ * const result = _defineData({ user: { name: 'John' } }, 'render:#');
+ * // Returns: { dataDeepLevel: 1, nestedData: [[{ name: 'John' }]] }
+ */
+declare function _defineData(dSource: any, action: string): object;

package/dist/methods/_defineType.d.ts

@@ -0,0 +1,15 @@
+export default _defineDataType;
+/**
+ * Determines the data type of a value for template processing.
+ *
+ * @param {any} data - Value to type-check
+ * @returns {string|undefined} Returns one of: 'null', 'primitive', 'function', 'array', 'object', or undefined
+ *
+ * @example
+ * _defineDataType(null); // 'null'
+ * _defineDataType('hello'); // 'primitive'
+ * _defineDataType([1,2,3]); // 'array'
+ * _defineDataType({}); // 'object'
+ * _defineDataType(() => {}); // 'function'
+ */
+declare function _defineDataType(data: any): string | undefined;

package/dist/methods/_readTemplate.d.ts

@@ -0,0 +1,24 @@
+export default _readTemplate;
+/**
+ * Parses and validates a template description object.
+ *
+ * Extracts placeholders, validates helpers, and prepares template for building.
+ *
+ * @param {object} tpl - Template description object
+ * @param {string} tpl.template - Template string with placeholders
+ * @param {object} [tpl.helpers={}] - Optional helper functions
+ * @param {object} [tpl.handshake] - Optional example data
+ *
+ * @returns {object} Template parsing result containing:
+ *   - hasError: Error message or null
+ *   - placeholders: Array of placeholder objects
+ *   - chop: Array of template parts
+ *   - helpers: Helper functions object
+ *   - handshake: Example data object
+ *   - snippets: Object mapping snippet names to placeholders
+ */
+declare function _readTemplate(tpl: {
+    template: string;
+    helpers?: object;
+    handshake?: object;
+}): object;

package/dist/methods/_renderHolder.d.ts

@@ -0,0 +1,17 @@
+export default _renderHolder;
+/**
+ * Renders a simple template by replacing placeholders with data values.
+ *
+ * Processes templates with basic placeholder substitution without actions or helpers.
+ * Only supports direct field replacement from the data object.
+ *
+ * @param {string} template - Template string with placeholders
+ * @param {object} data - Data object containing values for placeholder replacement
+ *
+ * @returns {string|null} Rendered template string or null if data is null
+ *
+ * @example
+ * const result = _renderHolder('Hello {{name}}!', { name: 'World' });
+ * // Returns: 'Hello World!'
+ */
+declare function _renderHolder(template: string, data: object): string | null;

package/dist/methods/_setupActions.d.ts

@@ -0,0 +1,19 @@
+export default _setupActions;
+/**
+ * Parses and organizes template actions into a structured setup by processing level.
+ *
+ * Converts action strings into structured objects with types and levels. Validates that
+ * there are enough level markers (#) for the data depth.
+ *
+ * @param {string[]} actions - Array of action strings to process
+ * @param {number} [dataDeepLevel=10] - Maximum depth level for nested data processing
+ *
+ * @returns {Object} Object with numeric keys containing arrays of action objects by level
+ *
+ * @example
+ * const setup = _setupActions(['render', '#', 'save:var'], 2);
+ * // Returns: { 0: [{type: 'render', name: 'render', level: 0}],
+ * //            1: [{type: 'save', name: 'var', level: 1}],
+ * //            2: [] }
+ */
+declare function _setupActions(actions: string[], dataDeepLevel?: number): any;

package/dist/methods/build.d.ts

@@ -0,0 +1,35 @@
+export default build;
+export type Template = {
+    /**
+     * - Data to be rendered;
+     */
+    template: string;
+    /**
+     * - Optional. Object with helper functions or simple templates for this template;
+     */
+    helpers?: object;
+    /**
+     * - Optional. Example for data to be rendered with;
+     */
+    handshake?: object;
+};
+export type tupleResult = any[];
+/**
+ * @typedef {Object} Template
+ * @property {string} template - Data to be rendered;
+ * @property {object} [helpers] - Optional. Object with helper functions or simple templates for this template;
+ * @property {object} [handshake] - Optional. Example for data to be rendered with;
+ */
+/**
+ * @typedef {Array}  tupleResult
+ * @property {boolean} 0 - Indicates success (true) or failure (false).
+ * @property {function} 1 - The rendering function or an error function.
+ */
+/**
+ *
+ * @param {Template} tpl - template definition;
+ * @param {boolean} [extra] - Optional. How to receive the answer - false:as a string(answer) or true: as tuple[success, answer];
+ * @param {object} [buildDependencies] - Optional. External dependencies injected;
+ * @returns {function|tupleResult} - rendering function
+ */
+declare function build(tpl: Template, extra?: boolean, buildDependencies?: object): Function | tupleResult;

package/dist/methods/render.d.ts

@@ -0,0 +1,25 @@
+export default render;
+/**
+ * Executes rendering and returns the rendered result.
+ *
+ * Handles both function-based and template-based rendering. Normalizes data objects
+ * by converting nested objects to their 'text' properties and arrays to their first elements.
+ *
+ * @param {object|string} theData - Data to be rendered. If string, becomes the 'text' property value.
+ * @param {string} name - Name of the render helper/template to execute
+ * @param {object} helpers - Object containing helper functions and templates
+ * @param {object} original - Original data context for full data access
+ * @param {object} dependencies - External dependencies available to helpers
+ * @param {...any} args - Additional arguments passed to the render function
+ *
+ * @returns {string} Rendered string result
+ *
+ * @example
+ * // Render with function helper
+ * const result = render(data, 'myHelper', helpers, originalData, deps);
+ *
+ * @example
+ * // Render with template
+ * const result = render(data, 'myTemplate', helpers, originalData, deps);
+ */
+declare function render(theData: object | string, name: string, helpers: object, original: object, dependencies: object, ...args: any[]): string;

package/dist/methods/settings.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    TG_PRX: string;
+    TG_SFX: string;
+    TG_SIZE_P: number;
+    TG_SIZE_S: number;
+};
+export default _default;

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@peter.naydenov/morph",
     "description": "Template engine",
-    "version": "3.1.4",
+    "version": "3.1.5",
     "license": "MIT",
     "author": "Peter Naydenov",
     "main": "./src/main.js",
     "type": "module",
-    "types": "./types/index.d.ts",
+    "types": "./dist/main.d.ts",
     "exports": {
         ".": {
             "import": "./src/main.js",
@@ -20,20 +20,22 @@
     "scripts": {
         "test": "mocha test",
         "cover": "c8 mocha",
-        "build": "rollup -c"
+        "build": "npm run build:types && rollup -c",
+        "build:types": "tsc"
     },
     "dependencies": {
         "@peter.naydenov/stack": "^3.0.0",
         "@peter.naydenov/walk": "^5.0.2"
     },
     "devDependencies": {
-        "@rollup/plugin-commonjs": "^28.0.6",
+        "@rollup/plugin-commonjs": "^29.0.0",
         "@rollup/plugin-node-resolve": "^16.0.3",
         "@rollup/plugin-terser": "^0.4.4",
         "c8": "^10.1.3",
-        "chai": "6.2.0",
-        "mocha": "11.7.4",
-        "rollup": "^4.52.4"
+        "chai": "6.2.1",
+        "mocha": "11.7.5",
+        "rollup": "^4.53.2",
+        "typescript": "^5.9.3"
     },
     "repository": {
         "type": "git",

package/src/main.js

@@ -24,15 +24,22 @@ const storage = ( () => ({default: {}}) ) ();
 
 
 /**
- *   Get a template from a storage.
+ * Retrieves a template from storage.
  * 
- *   @param {string[]} location - The location of the template. Array of two elements.
- *                             The first element is the name of the template. The second element
- *                             is optional and is the name of the storage. Defaults to 'default'.
+ * @param {string[]} location - The location of the template. Array of two elements:
+ *   - First element: The name of the template
+ *   - Second element (optional): The name of the storage. Defaults to 'default'
  * 
- *   @returns {function } The template (a render function) if it exists in the storage.
- *                             An function that returns an error message if 
- *                             either the storage or template does not exist.
+ * @returns {Function} The template (render function) if found, or an error function that returns
+ *   an error message if the storage or template doesn't exist.
+ * 
+ * @example
+ * // Get template from default storage
+ * const template = get(['myTemplate']);
+ * 
+ * @example
+ * // Get template from custom storage
+ * const template = get(['myTemplate', 'customStorage']);
  */
 function get ( location ) {
     if ( !(location instanceof Array) ) {  
@@ -61,20 +68,28 @@ function get ( location ) {
 
 
 /**
- *   Add a template to a storage.
- * 
- *   If the template is already a function, it is added to the storage.
- *   If the template is a template description (an object), it is built and
- *   added to the storage.
- *   If the template is broken, an error message is printed in the console
- *   and the template is not added to the storage.
- * 
- *   @param {string[]} location - The location to add the template to. Array of two elements.
- *                             The first element is the name of the template. The second element
- *                             is optional and is the name of the storage. Defaults to 'default'.
- *   @param {object|function|null} tplfn - The template description or the already built template function.
- *   @param {...any} args - Additional arguments to be passed to the build function.
- *                           Only used if the first argument is a template description.
+ * Adds a template to storage.
+ * 
+ * If the template is already a function, it's added directly to storage.
+ * If it's a template description object, it's built first and then added.
+ * If the template is null or broken, a warning/error is logged and it's not added.
+ * 
+ * @param {string[]} location - The location to add the template to. Array of two elements:
+ *   - First element: The name of the template
+ *   - Second element (optional): The name of the storage. Defaults to 'default'
+ * @param {object|function|null} tplfn - The template description object, pre-built template function, or null
+ * @param {...any} args - Additional arguments passed to the build function (only used when tplfn is a template description)
+ * 
+ * @example
+ * // Add a pre-built template function
+ * add(['myTemplate'], templateFunction);
+ * 
+ * @example
+ * // Add and build a template description
+ * add(['myTemplate'], {
+ *   template: 'Hello {{name}}!',
+ *   helpers: { name: (data) => data.data.name }
+ * });
  */
 function add ( location, tplfn, ...args ) {
     const [ name, strName='default'] = location
@@ -98,11 +113,20 @@ function add ( location, tplfn, ...args ) {
 
 
 /**
- *   Returns an array of all the names of the templates in the given storages.
- *   No arguments - will return the list of templates in the 'default' storage.
+ * Returns an array of template names from specified storages.
+ * 
+ * @param {string[]} [storageNames=['default']] - Array of storage names to retrieve template names from.
+ *   Defaults to ['default'] if not provided.
  * 
- *   @param {string[]} [storageNames=['default']] - The names of the storages to retrieve template names from;
- *   @returns {string[]} An array of all the template names in the given storages;
+ * @returns {string[]} Array of all template names from the specified storages.
+ * 
+ * @example
+ * // List templates from default storage
+ * const templates = list();
+ * 
+ * @example
+ * // List templates from multiple storages
+ * const templates = list(['default', 'customStorage']);
  */
 function list ( storageNames=['default'] ) {
     let r = storageNames.map ( strName => {
@@ -115,8 +139,13 @@ function list ( storageNames=['default'] ) {
 
 
 /**
- * Clears all templates from the storages.
- * This function deletes all storages. Storage 'default' will be reset to an empty object.
+ * Clears all templates from all storages.
+ * 
+ * Deletes all custom storages and resets the 'default' storage to an empty object.
+ * 
+ * @example
+ * // Clear all templates
+ * clear();
  */
 function clear ( ) {
     const keys = Object.keys ( storage )
@@ -130,13 +159,22 @@ function clear ( ) {
 
 
 /**
- *   Removes a template from the storage.
+ * Removes a template from storage.
+ * 
+ * @param {string[]} location - The location of the template to remove. Array of two elements:
+ *   - First element: The name of the template
+ *   - Second element (optional): The name of the storage. Defaults to 'default'
+ * 
+ * @returns {void|string} Returns an error message if the storage or template doesn't exist,
+ *   otherwise returns undefined.
  * 
- *   @param {string[]} location - The location to remove the template from. Array of two elements.
- *                             The first element is the name of the template. The second element
- *                             is optional and is the name of the storage. Defaults to 'default'.
+ * @example
+ * // Remove template from default storage
+ * remove(['myTemplate']);
  * 
- *   @returns {void|string} An error message if the storage or template does not exist.
+ * @example
+ * // Remove template from custom storage
+ * remove(['myTemplate', 'customStorage']);
  */
 function remove ( location ) {
     const [name, strName='default'] = location;

package/src/methods/_actionSupply.js

@@ -2,6 +2,22 @@ import stack from "@peter.naydenov/stack"
 
 
 
+/**
+ * Generator function that supplies actions in a controlled sequence using a stack.
+ * 
+ * Manages the flow of actions through different processing levels, allowing for
+ * dynamic action insertion during processing.
+ * 
+ * @param {Object} act - Object containing action arrays organized by level
+ * @param {number} level - Maximum processing level
+ * @returns {Generator} Generator that yields action objects in sequence
+ * 
+ * @example
+ * const generator = _actionSupply(actionSetup, 2);
+ * for (const action of generator) {
+ *   // Process each action
+ * }
+ */
 function* _actionSupply ( act, level ) {
     let action = stack ({ type:'LIFO' });
     for ( let i=0; i<=level; i++ ) {

package/src/methods/_chopTemplates.js

@@ -1,3 +1,18 @@
+/**
+ * Creates a template chopping function that splits text into parts and placeholders.
+ * 
+ * @param {object} settings - Configuration object containing template delimiters
+ * @param {string} settings.TG_PRX - Opening delimiter (e.g., '{{')
+ * @param {string} settings.TG_SFX - Closing delimiter (e.g., '}}')
+ * @param {number} settings.TG_SIZE_P - Length of opening delimiter
+ * @param {number} settings.TG_SIZE_S - Length of closing delimiter
+ * 
+ * @returns {Function} Function that chops template text into array parts
+ * 
+ * @example
+ * const chop = _chopTemplate(settings);
+ * const result = chop('Hello {{name}}!');
+ */
 function _chopTemplate ( settings ) {
     return function _chopTemplate ( text ) {
         const { TG_PRX, TG_SFX, TG_SIZE_P, TG_SIZE_S } = settings;
@@ -38,7 +53,13 @@ function _chopTemplate ( settings ) {
     
     
     
-    function showError (type) {
+    /**
+ * Returns error messages for template parsing failures.
+ * 
+ * @param {string} type - Error type identifier
+ * @returns {string} Human-readable error message
+ */
+function showError (type) {
             switch (type) {
                   case 'notAString': 
                             return `Error: Template is not a string.`

package/src/methods/_defineData.js

@@ -2,6 +2,29 @@ import walk from '@peter.naydenov/walk'
 
 
 
+/**
+ * Processes data source based on action requirements and creates nested data structure.
+ * 
+ * Analyzes the data source and action to determine if nested data processing is needed.
+ * If action contains '#', it walks through the data structure to collect nested objects.
+ * 
+ * @param {any} dSource - The data source to process (function, null, string, or object)
+ * @param {string} action - Action string that may contain '#' indicating nested processing
+ * 
+ * @returns {object} Data processing result containing:
+ *   - dataDeepLevel: Maximum nesting level found
+ *   - nestedData: Array of nested data arrays organized by level
+ * 
+ * @example
+ * // Simple data without nesting
+ * const result = _defineData('hello', 'render');
+ * // Returns: { dataDeepLevel: 0, nestedData: [['hello']] }
+ * 
+ * @example
+ * // Nested data with '#' action
+ * const result = _defineData({ user: { name: 'John' } }, 'render:#');
+ * // Returns: { dataDeepLevel: 1, nestedData: [[{ name: 'John' }]] }
+ */
 function _defineData ( dSource, action ) {
     const nestedData = [];
     let dataDeepLevel = 0;
@@ -18,7 +41,16 @@ function _defineData ( dSource, action ) {
             return { dataDeepLevel:0, nestedData }
         }
         
-    function findObjects ({key, value, breadcrumbs}) {
+    /**
+ * Callback function for walking through data structure to collect nested objects.
+ * 
+ * @param {object} params - Walk parameters
+ * @param {string} params.key - Current key being processed
+ * @param {any} params.value - Current value being processed
+ * @param {string} params.breadcrumbs - Path to current value as breadcrumb string
+ * @returns {any} Returns the value unchanged
+ */
+function findObjects ({key, value, breadcrumbs}) {
                     if ( key === breadcrumbs ) {
                             nestedData[0] = [ value ]
                             return value

package/src/methods/_defineType.js

@@ -1,3 +1,16 @@
+/**
+ * Determines the data type of a value for template processing.
+ * 
+ * @param {any} data - Value to type-check
+ * @returns {string|undefined} Returns one of: 'null', 'primitive', 'function', 'array', 'object', or undefined
+ * 
+ * @example
+ * _defineDataType(null); // 'null'
+ * _defineDataType('hello'); // 'primitive'
+ * _defineDataType([1,2,3]); // 'array'
+ * _defineDataType({}); // 'object'
+ * _defineDataType(() => {}); // 'function'
+ */
 function _defineDataType ( data ) {
     
     if ( data == null )              return  'null'

package/src/methods/_readTemplate.js

@@ -3,12 +3,36 @@ import _chopTemplate from "./_chopTemplates.js"
 
 
 
+/**
+ * Normalizes field data by returning null for falsy values.
+ * 
+ * @param {any} field - Field value to normalize
+ * @returns {any|null} Returns the field if truthy, null otherwise
+ */
 function readData ( field ) {
     return   field ? field : null
 } // readData func.
 
 
 
+/**
+ * Parses and validates a template description object.
+ * 
+ * Extracts placeholders, validates helpers, and prepares template for building.
+ * 
+ * @param {object} tpl - Template description object
+ * @param {string} tpl.template - Template string with placeholders
+ * @param {object} [tpl.helpers={}] - Optional helper functions
+ * @param {object} [tpl.handshake] - Optional example data
+ * 
+ * @returns {object} Template parsing result containing:
+ *   - hasError: Error message or null
+ *   - placeholders: Array of placeholder objects
+ *   - chop: Array of template parts
+ *   - helpers: Helper functions object
+ *   - handshake: Example data object
+ *   - snippets: Object mapping snippet names to placeholders
+ */
 function _readTemplate ( tpl ) {
     const 
              { template, helpers={}, handshake } = tpl

package/src/methods/_renderHolder.js

@@ -3,6 +3,21 @@ import settings from './settings.js'
 
 
 
+/**
+ * Renders a simple template by replacing placeholders with data values.
+ * 
+ * Processes templates with basic placeholder substitution without actions or helpers.
+ * Only supports direct field replacement from the data object.
+ * 
+ * @param {string} template - Template string with placeholders
+ * @param {object} data - Data object containing values for placeholder replacement
+ * 
+ * @returns {string|null} Rendered template string or null if data is null
+ * 
+ * @example
+ * const result = _renderHolder('Hello {{name}}!', { name: 'World' });
+ * // Returns: 'Hello World!'
+ */
 function _renderHolder ( template, data ) {
     // Data should be an object. No array, no string.
     if ( data == null )   return null  

package/src/methods/_setupActions.js

@@ -1,3 +1,20 @@
+/**
+ * Parses and organizes template actions into a structured setup by processing level.
+ * 
+ * Converts action strings into structured objects with types and levels. Validates that
+ * there are enough level markers (#) for the data depth.
+ * 
+ * @param {string[]} actions - Array of action strings to process
+ * @param {number} [dataDeepLevel=10] - Maximum depth level for nested data processing
+ * 
+ * @returns {Object} Object with numeric keys containing arrays of action objects by level
+ * 
+ * @example
+ * const setup = _setupActions(['render', '#', 'save:var'], 2);
+ * // Returns: { 0: [{type: 'render', name: 'render', level: 0}], 
+ * //            1: [{type: 'save', name: 'var', level: 1}], 
+ * //            2: [] }
+ */
 function _setupActions ( actions, dataDeepLevel=10 ) {
     let 
       actSetup = {}

package/src/methods/render.js

@@ -3,15 +3,27 @@ import _renderHolder from "./_renderHolder.js"
 
 
 /**
+ * Executes rendering and returns the rendered result.
  * 
- *  Execute rendering and return the results
+ * Handles both function-based and template-based rendering. Normalizes data objects
+ * by converting nested objects to their 'text' properties and arrays to their first elements.
  * 
- * @param {object|string} theData - Data to be rendered. If it's a string, it's the value of 'text' property.
- * @param {string} name - Name of the render to be executed.
- * @param {object} helpers - Object with helper functions or templates.
- * @param {...any} args - Extra arguments to be passed to the render function.
+ * @param {object|string} theData - Data to be rendered. If string, becomes the 'text' property value.
+ * @param {string} name - Name of the render helper/template to execute
+ * @param {object} helpers - Object containing helper functions and templates
+ * @param {object} original - Original data context for full data access
+ * @param {object} dependencies - External dependencies available to helpers
+ * @param {...any} args - Additional arguments passed to the render function
  * 
- * @returns {string} - Rendered string.
+ * @returns {string} Rendered string result
+ * 
+ * @example
+ * // Render with function helper
+ * const result = render(data, 'myHelper', helpers, originalData, deps);
+ * 
+ * @example
+ * // Render with template
+ * const result = render(data, 'myTemplate', helpers, originalData, deps);
  */
 function render ( theData, name, helpers, original, dependencies, ...args ) {
 // *** Executes rendering and return the results
@@ -21,7 +33,13 @@ function render ( theData, name, helpers, original, dependencies, ...args ) {
                                         if ( value instanceof Array    ) theData[key] = value[0]
                                 })
                     }
-                function setRenderData ( d={} ) {
+                /**
+ * Normalizes render data by wrapping strings in text objects.
+ * 
+ * @param {any} d - Data to normalize
+ * @returns {object} Returns { text: d } if d is string, otherwise returns d unchanged
+ */
+function setRenderData ( d={} ) {
                                 if ( typeof d === 'string' )  return { text: d }
                                 else return d
                         } // setRenderData func.

package/src/methods/settings.js

@@ -1,3 +1,14 @@
+/**
+ * Template engine configuration settings.
+ * 
+ * Defines the delimiters and sizes used for template placeholder parsing.
+ * 
+ * @type {Object}
+ * @property {string} TG_PRX - Opening tag prefix for placeholders ('{{')
+ * @property {string} TG_SFX - Closing tag suffix for placeholders ('}}')
+ * @property {number} TG_SIZE_P - Length of opening tag prefix (2)
+ * @property {number} TG_SIZE_S - Length of closing tag suffix (2)
+ */
 export default {
     TG_PRX: '{{'
   , TG_SFX: '}}'

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "./dist",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test",
+    "types"
+  ]
+}

package/types/index.d.ts

@@ -1,60 +0,0 @@
-declare module '@peter.naydenov/morph' {
-  /**
-   * Template description object
-   */
-  interface TemplateDescription {
-    /**
-     * Template string with placeholders
-     */
-    template: string;
-    /**
-     * Optional helper functions or templates
-     */
-    helpers?: Record<string, any>;
-    /**
-     * Optional example data for rendering
-     */
-    handshake?: Record<string, any>;
-  }
-
-  /**
-   * Build a component from template description
-   */
-  function build(tpl: TemplateDescription, extra?: boolean, buildDependencies?: Record<string, any>): Function;
-
-  /**
-   * Get a component from component storage
-   */
-  function get(location: [string, string?]): Function;
-
-  /**
-   * Add a component to component storage
-   */
-  function add(location: [string, string?], tplfn: Function | TemplateDescription, ...args: any[]): void;
-
-  /**
-   * List the names of all components in the component storage
-   */
-  function list(storageNames?: string[]): string[];
-
-  /**
-   * Clear up all the components in the storage
-   */
-  function clear(): void;
-
-  /**
-   * Remove a template from component storage
-   */
-  function remove(location: [string, string?]): void | string;
-
-  const morphAPI: {
-    build: typeof build;
-    get: typeof get;
-    add: typeof add;
-    list: typeof list;
-    clear: typeof clear;
-    remove: typeof remove;
-  };
-
-  export default morphAPI;
-}