@peter.naydenov/morph 3.1.4 → 3.2.0

package/specs/001-extend-templates/tasks.md

@@ -0,0 +1,255 @@
+---
+
+description: "Task list template for feature implementation"
+---
+
+# Tasks: Extend Templates
+
+**Input**: Design documents from `/specs/001-extend-templates/`
+**Prerequisites**: plan.md (required), spec.md (required for user stories), research.md, data-model.md, contracts/
+
+**Tests**: Tests are required per feature requirements (FR-007, FR-008, FR-009)
+
+**Organization**: Tasks are grouped by user story to enable independent implementation and testing of each story.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (e.g., US1, US2, US3)
+- Include exact file paths in descriptions
+
+## Path Conventions
+
+- **Single project**: `src/`, `test/` at repository root
+- Paths shown below assume single project - adjust based on plan.md structure
+
+## Phase 1: Setup (Shared Infrastructure)
+
+**Purpose**: Project initialization and basic structure
+
+- [X] T001 [P] Review existing code structure in src/ and test/
+- [ ] T002 [P] Identify files to modify for 'set' command support
+
+---
+
+## Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose**: Core infrastructure that MUST be complete before ANY user story can be implemented
+
+**⚠️ CRITICAL**: No user story work can begin until this phase is complete
+
+- [ ] T003 Add 'set' command support to src/methods/render.js
+- [ ] T004 Update src/methods/build.js to handle template extensions
+- [ ] T005 Implement placeholder replacement logic in src/methods/_chopTemplates.js
+- [ ] T006 Implement helper merging logic in src/methods/_defineData.js
+- [ ] T007 Implement handshake merging logic in src/methods/_defineData.js
+
+**Checkpoint**: Foundation ready - user story implementation can now begin in parallel
+
+---
+
+## Phase 3: User Story 1 - Create Template Variants (Priority: P1) 🎯 MVP
+
+**Goal**: Enable modification of placeholder definitions in existing templates to create variants
+
+**Independent Test**: Create a base template, use 'set' to modify placeholders, render and verify changes
+
+### Tests for User Story 1 ⚠️
+
+> **NOTE: Write these tests FIRST, ensure they FAIL before implementation**
+
+- [ ] T008 [P] [US1] Contract test for 'set' command in test/08-set-contract.test.js
+- [ ] T009 [P] [US1] Integration test for placeholder replacement in test/09-placeholder-integration.test.js
+
+### Implementation for User Story 1
+
+- [ ] T010 [US1] Implement placeholder identification by position/name in src/methods/_chopTemplates.js
+- [ ] T011 [US1] Implement placeholder replacement in 'set' command in src/methods/render.js
+- [ ] T012 [US1] Add validation for placeholder definitions in src/methods/_chopTemplates.js
+
+**Checkpoint**: At this point, User Story 1 should be fully functional and testable independently
+
+---
+
+## Phase 4: User Story 2 - Add/Overwrite Helpers (Priority: P1)
+
+**Goal**: Allow adding new helpers or overwriting existing ones in templates dynamically
+
+**Independent Test**: Extend a template with new helpers, render and verify helper execution
+
+### Tests for User Story 2 ⚠️
+
+- [ ] T013 [P] [US2] Contract test for helper merging in test/10-helper-contract.test.js
+- [ ] T014 [P] [US2] Integration test for helper overwriting in test/11-helper-integration.test.js
+
+### Implementation for User Story 2
+
+- [ ] T015 [US2] Implement helper merging logic in src/methods/_defineData.js
+- [ ] T016 [US2] Ensure new helpers overwrite existing ones in src/methods/build.js
+- [ ] T017 [US2] Preserve original helpers in extended templates in src/methods/build.js
+
+**Checkpoint**: At this point, User Stories 1 AND 2 should both work independently
+
+---
+
+## Phase 5: User Story 3 - Provide Alternative Handshake Data (Priority: P2)
+
+**Goal**: Enable providing alternative demo data for template testing
+
+**Independent Test**: Extend template with new handshake, render in demo mode with new data
+
+### Tests for User Story 3 ⚠️
+
+- [ ] T018 [P] [US3] Contract test for handshake merging in test/12-handshake-contract.test.js
+- [ ] T019 [P] [US3] Integration test for demo rendering with new handshake in test/13-handshake-integration.test.js
+
+### Implementation for User Story 3
+
+- [ ] T020 [US3] Implement handshake merging logic in src/methods/_defineData.js
+- [ ] T021 [US3] Update demo rendering to use merged handshake in src/methods/render.js
+
+**Checkpoint**: At this point, User Stories 1, 2 AND 3 should all work independently
+
+---
+
+## Phase 6: User Story 4 - Handle Missing Helpers Gracefully (Priority: P2)
+
+**Goal**: Provide clear error messages when rendering with missing helpers
+
+**Independent Test**: Attempt to render template with missing helper, verify error message
+
+### Tests for User Story 4 ⚠️
+
+- [ ] T022 [P] [US4] Contract test for error handling in test/14-error-contract.test.js
+- [ ] T023 [P] [US4] Integration test for missing helper errors in test/15-error-integration.test.js
+
+### Implementation for User Story 4
+
+- [ ] T024 [US4] Implement missing helper detection in src/methods/_actionSupply.js
+- [ ] T025 [US4] Add error message formatting "Helper '<name>' is not available" in src/methods/render.js
+- [ ] T026 [US4] Support listing multiple missing helpers in error messages in src/methods/render.js
+
+**Checkpoint**: At this point, User Stories 1-4 should all work independently
+
+---
+
+## Phase 7: User Story 5 - Remove Routing Actions (Priority: P3)
+
+**Goal**: Remove inconsistent routing actions from the action system
+
+**Independent Test**: Verify routing actions are no longer available, alternatives work
+
+### Tests for User Story 5 ⚠️
+
+- [ ] T027 [P] [US5] Contract test for removed routing actions in test/16-routing-contract.test.js
+- [ ] T028 [P] [US5] Integration test for alternative action patterns in test/17-routing-integration.test.js
+
+### Implementation for User Story 5
+
+- [ ] T029 [US5] Remove routing action implementations from src/methods/_setupActions.js
+- [ ] T030 [US5] Update action validation to reject routing actions in src/methods/_setupActions.js
+
+**Checkpoint**: All user stories should now be independently functional
+
+---
+
+## Phase 8: Polish & Cross-Cutting Concerns
+
+**Purpose**: Improvements that affect multiple user stories
+
+- [ ] T031 [P] Update JSDoc comments in src/methods/*.js
+- [ ] T032 [P] Update TypeScript definitions in morph.d.ts
+- [ ] T033 [P] Update tests for new features in test/*.js
+- [ ] T034 [P] Update README.md with 'set' command documentation
+- [ ] T035 Run npm test to validate all changes
+- [ ] T036 Run npm run lint to check code quality
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Setup (Phase 1)**: No dependencies - can start immediately
+- **Foundational (Phase 2)**: Depends on Setup completion - BLOCKS all user stories
+- **User Stories (Phase 3-7)**: All depend on Foundational phase completion
+  - User stories can then proceed in parallel (if staffed)
+  - Or sequentially in priority order (P1 → P2 → P3)
+- **Polish (Phase 8)**: Depends on all user stories being complete
+
+### User Story Dependencies
+
+- **User Story 1 (P1)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+- **User Story 2 (P1)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+- **User Story 3 (P2)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+- **User Story 4 (P2)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+- **User Story 5 (P3)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+
+### Within Each User Story
+
+- Tests (if included) MUST be written and FAIL before implementation
+- Core implementation before integration
+- Story complete before moving to next priority
+
+### Parallel Opportunities
+
+- All Setup tasks marked [P] can run in parallel
+- All Foundational tasks marked [P] can run in parallel (within Phase 2)
+- Once Foundational phase completes, all user stories can start in parallel (if team capacity allows)
+- All tests for a user story marked [P] can run in parallel
+- Different user stories can be worked on in parallel by different team members
+
+---
+
+## Parallel Example: User Story 1
+
+```bash
+# Launch all tests for User Story 1 together:
+Task: "Contract test for 'set' command in test/08-set-contract.test.js"
+Task: "Integration test for placeholder replacement in test/09-placeholder-integration.test.js"
+```
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 1 Only)
+
+1. Complete Phase 1: Setup
+2. Complete Phase 2: Foundational (CRITICAL - blocks all stories)
+3. Complete Phase 3: User Story 1
+4. **STOP and VALIDATE**: Test User Story 1 independently
+5. Deploy/demo if ready
+
+### Incremental Delivery
+
+1. Complete Setup + Foundational → Foundation ready
+2. Add User Story 1 → Test independently → Deploy/Demo (MVP!)
+3. Add User Story 2 → Test independently → Deploy/Demo
+4. Add User Story 3 → Test independently → Deploy/Demo
+5. Add User Story 4 → Test independently → Deploy/Demo
+6. Add User Story 5 → Test independently → Deploy/Demo
+7. Each story adds value without breaking previous stories
+
+### Parallel Team Strategy
+
+With multiple developers:
+
+1. Team completes Setup + Foundational together
+2. Once Foundational is done:
+   - Developer A: User Stories 1 & 2
+   - Developer B: User Stories 3 & 4
+   - Developer C: User Story 5
+3. Stories complete and integrate independently
+
+---
+
+## Notes
+
+- [P] tasks = different files, no dependencies
+- [Story] label maps task to specific user story for traceability
+- Each user story should be independently completable and testable
+- Verify tests fail before implementing
+- Commit after each task or logical group
+- Stop at any checkpoint to validate story independently
+- Avoid: vague tasks, same file conflicts, cross-story dependencies that break independence

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
@@ -28,52 +52,28 @@ function _readTemplate ( tpl ) {
 
     if ( typeof chop  === 'string' )   hasError = chop
     else {
-                    chop.forEach ( (item,i) => {
-                                    const 
-                                            // Placeholder contains: Opening tag(TG_PRX), dataName, delimiter(:), list of operations, placeholder's name, closing tag(TG_SFX)
-                                              finding = RegExp ( TG_PRX + '\\s*(.*?)\\s*(?::\\s*(.*?)\\s*)?(?::\\s*(.*?)\\s*)?' + TG_SFX, 'g' )
-                                            , isPlaceholder = item.includes( TG_PRX )
-                                            ;
-                                           
-                                    if ( isPlaceholder ) {
-                                                    const x = finding.exec ( item )
-                                                    if ( !x ) return
-                                                    let holder = {
-                                                                      index: i
-                                                                    , data   : readData    ( x[1] )
-                                                                    , action : x[2] ? x[2].split(',').map ( x => x.trim()) : null 
-                                                                    , name   : x[3] ? x[3].trim() : null
-                                                                }
-                                                    placeholders.push ( holder )
-                                                    snippets[placeholders.length-1] = holder
-                                                    if ( holder.name )   snippets[holder.name] = holder
-                                            } // if isPlaceholder
-                            }) // forEach chop
-            } // else error
-
-
-
-    // Check helpers - sanity check
-    placeholders.forEach ( holder => {
-                if ( !holder.action ) return
-                holder.action.every ( act => {
-                                        if ( act === '#'  )   return true
-                                        if ( act === '^^' )   return true
-                                        if ( act.startsWith('^') && act !== '^^' )   return true
-                                        if ( act.startsWith ( '?' )) act = act.replace ( '?', '' )
-                                        if ( act.startsWith ( '+' )) act = act.replace ( '+', '' )
-                                        if ( act.startsWith ( '[]' )) act = act.replace ( '[]', '' )
-                                        if ( act.startsWith ( '>' )) act = act.replace ( '>', '' )
-                                        if ( act === ''   )   return true
-                                        if ( helpers[act] )   return true 
-                                        else {
-                                                hasError = `Error: Missing helper: ${act}`
-                                                return false
-                                                }
-                        }) // every action
-            }) // forEach placeholders
-
-
+              chop.forEach ( (item,i) => {
+                              const 
+                                      // Placeholder contains: Opening tag(TG_PRX), dataName, delimiter(:), list of operations, placeholder's name, closing tag(TG_SFX)
+                                        finding = RegExp ( TG_PRX + '\\s*(.*?)\\s*(?::\\s*(.*?)\\s*)?(?::\\s*(.*?)\\s*)?' + TG_SFX, 'g' )
+                                      , isPlaceholder = item.includes( TG_PRX )
+                                      ;
+                                      
+                              if ( isPlaceholder ) {
+                                              const x = finding.exec ( item )
+                                              if ( !x ) return
+                                              let holder = {
+                                                                index: i
+                                                              , data   : readData    ( x[1] )
+                                                              , action : x[2] ? x[2].split(',').map ( x => x.trim()) : null 
+                                                              , name   : x[3] ? x[3].trim() : null
+                                                      }
+                                              placeholders.push ( holder )
+                                              snippets[placeholders.length-1] = holder
+                                              if ( holder.name )   snippets[holder.name] = holder
+                                      } // if isPlaceholder
+                      }) // forEach chop
+      } // else error
 
     return {
               hasError 

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