@peter.naydenov/morph 3.1.5 → 3.2.0

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

@@ -0,0 +1,90 @@
+# Implementation Plan: Extend Templates
+
+**Branch**: `001-extend-templates` | **Date**: 2025-11-30 | **Spec**: specs/001-extend-templates/spec.md
+**Input**: Feature specification from /specs/001-extend-templates/spec.md
+
+**Note**: This template is filled in by the `/speckit.plan` command. See `.specify/templates/commands/plan.md` for the execution workflow.
+
+## Summary
+
+Extend Morph templates with 'set' command to modify placeholders, helpers, handshake without altering originals. Technical approach: Add 'set' method to template functions, merge extensions with originals, remove routing actions.
+
+## Technical Context
+
+**Language/Version**: JavaScript (ES6+)  
+
+**Primary Dependencies**: None (existing library)  
+
+**Storage**: N/A  
+
+**Testing**: Existing test suite  
+
+**Target Platform**: Browser and Node.js
+
+**Project Type**: Library  
+
+**Performance Goals**: Template extensions created and tested in under 5 minutes  
+
+**Constraints**: Maintain backward compatibility, no breaking changes  
+
+**Scale/Scope**: Small feature addition to existing library
+
+## Constitution Check
+
+*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
+
+- I. Logic-Less Templating: PASS - Extensions maintain logic-less syntax.
+- II. Builtin Storage: PASS - No impact.
+- III. Action System (NON-NEGOTIABLE): PASS - 'set' is a command, not action; removing inconsistent routing actions improves system.
+- IV. Demo and Handshake: PASS - Extending handshake aligns.
+- V. Extensibility: PASS - Adds extensibility via 'set'.
+- VI. Debuggability: PASS - Empty placeholders support partial render principle.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/[###-feature]/
+├── plan.md              # This file (/speckit.plan command output)
+├── research.md          # Phase 0 output (/speckit.plan command)
+├── data-model.md        # Phase 1 output (/speckit.plan command)
+├── quickstart.md        # Phase 1 output (/speckit.plan command)
+├── contracts/           # Phase 1 output (/speckit.plan command)
+└── tasks.md             # Phase 2 output (/speckit.tasks command - NOT created by /speckit.plan)
+```
+
+### Source Code (repository root)
+
+```text
+src/
+├── methods/
+│   ├── _actionSupply.js
+│   ├── _chopTemplates.js
+│   ├── _defineData.js
+│   ├── _defineType.js
+│   ├── _readTemplate.js
+│   ├── _renderHolder.js
+│   ├── _setupActions.js
+│   ├── build.js
+│   ├── render.js
+│   └── settings.js
+├── main.js
+└── ...
+
+tests/
+├── 01-chop.test.js
+├── 02-build.test.js
+├── 03-storage.test.js
+├── 04-commands.js
+├── 05-data.test.js
+├── 06-deps-injection.js
+├── 07-errors.test.js
+└── ...
+```
+
+**Structure Decision**: Single project library structure. Source in src/, tests in test/. Feature will modify build.js and render.js primarily.
+
+## Complexity Tracking
+
+No constitution violations to justify.

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

@@ -0,0 +1,56 @@
+# Quickstart: Extend Templates
+
+**Feature**: Extend Templates
+**Date**: 2025-11-30
+
+## Overview
+
+The `set` command allows you to create extended versions of existing templates by modifying placeholders, adding helpers, and providing alternative handshake data.
+
+## Basic Usage
+
+```javascript
+import morph from '@peter.naydenov/morph';
+
+// Create a base template
+const baseTemplate = morph.build({
+  template: `Hello {{ name }}!`,
+  helpers: {},
+  handshake: { name: 'World' }
+});
+
+// Extend with new placeholder and helper
+const extendedTemplate = baseTemplate('set', {
+  placeholders: {
+    0: '{{ greeting: formatGreeting }}'  // Replace position 0
+  },
+  helpers: {
+    formatGreeting: (data) => data.toUpperCase()
+  },
+  handshake: {
+    greeting: 'Hello'
+  }
+});
+
+// Render the extended template
+const result = extendedTemplate('render', { greeting: 'Hi' });
+console.log(result); // "HI!"
+```
+
+## Key Points
+
+- `set` creates a new template function, leaving the original unchanged
+- Placeholders can be identified by position (number) or name (string)
+- New helpers overwrite existing ones with the same name
+- Handshake data is merged
+- Empty placeholders `{{}}` remain untouched if no data provided
+
+## Error Handling
+
+If a required helper is missing during render:
+
+```javascript
+// Will return: "Helper 'missingHelper' is not available"
+const result = template('render', { data: 'value' });
+```</content>
+<parameter name="filePath">specs/001-extend-templates/quickstart.md

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

@@ -0,0 +1,18 @@
+# Research: Extend Templates
+
+**Feature**: Extend Templates
+**Date**: 2025-11-30
+
+No unknowns identified in technical context. All implementation details known from existing Morph library codebase.
+
+- Language/Version: JavaScript (ES6+) - already in use
+- Dependencies: None new - extending existing library
+- Storage: N/A - in-memory operations
+- Testing: Existing test suite - will extend
+- Platform: Browser/Node.js - already supported
+- Performance: Under 5 minutes - developer time, no system perf impact
+- Constraints: Backward compatibility - standard for library updates
+- Scale: Small feature - fits within existing architecture
+
+**Decision**: No research required, proceed to design phase.</content>
+<parameter name="filePath">specs/001-extend-templates/research.md

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

@@ -0,0 +1,139 @@
+# Feature Specification: Extend Templates
+
+**Feature Branch**: `001-extend-templates`
+**Created**: 2025-11-30
+**Status**: Draft
+**Input**: User description: "- Empty placeholders - {{}}
+- Extend templates: Change of placeholder definitions, add/overwrite helpers, provide alternative handshake data. template ('set',{ plachholders:{nameOrPosition: newPlaceholderDefinition}, helpers: { helpers}, handshake:{ new Handshake}},). Result is a new function(template), ready to receive data;
+- Building templates - will not have 'fail' response, because we could build templates without having all helpers available. They can come latter.
+- 'Set' creates a new template. Current template is not changed;
+- What if we trying to render a template that don't have a helper? - it will return error as a render result. Will explain that renderFunction isn't available;
+- Routing actions will be removed. Too unconsistant with other actions. It's can be solved with normal render functions by providing a list of possible templates. It's something that is possible even now;
+- Update 'tests' according new features;
+- Check jsdoc and update it according code changes. Extend jsdoc where possible. Update .d.ts type definitions; "
+
+## Out of Scope
+
+- Modifying the original template in place; 'set' always creates a new template.
+- Adding new action types to the system beyond 'set' and existing ones.
+
+## Clarifications
+
+### Session 2025-11-30
+
+- Q: What should happen with empty placeholders {{}}? → A: Leave empty placeholders {{}} untouched in output when no data is provided.
+- Q: What should be the exact error message format when a helper is missing? → A: Helper '<name>' is not available
+- Q: How are placeholders identified in the 'set' command? → A: By position (number) or name (string); new placeholders replace old ones at that position/name.
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Create Template Variants (Priority: P1)
+
+As a developer using the Morph library, I want to modify placeholder definitions in an existing template so I can create variants for different data structures without duplicating template code.
+
+**Why this priority**: Enables template reuse and reduces code duplication.
+
+**Independent Test**: Can be tested by creating a base template, extending it with modified placeholders, and rendering with different data structures.
+
+**Acceptance Scenarios**:
+
+1. **Given** a template with placeholders, **When** I use 'set' command to change placeholder definitions, **Then** the new template renders with modified behavior.
+2. **Given** a template, **When** I extend it with new placeholders, **Then** the new template includes both original and new placeholders.
+
+---
+
+### User Story 2 - Add/Overwrite Helpers (Priority: P1)
+
+As a developer, I want to add new helpers or overwrite existing ones in a template so I can extend functionality dynamically.
+
+**Why this priority**: Allows dynamic extension of template capabilities. Mixing templates with different sets of helpers. Extend templates without breaking existing functionality and minimal adiditional code.
+
+**Independent Test**: Can be tested by extending a template with new helpers and verifying they are used in rendering.
+
+**Acceptance Scenarios**:
+
+1. **Given** a template with helpers, **When** I use 'set' to add new helpers, **Then** the new template includes the additional helpers.
+2. **Given** a template, **When** I overwrite an existing helper, **Then** the new template uses the updated helper.
+
+---
+
+### User Story 3 - Provide Alternative Handshake Data (Priority: P2)
+
+As a developer, I want to provide alternative demo data for a template so I can test different scenarios. Helpfull for testing component behavior with different data.
+
+**Why this priority**: Improves testing and prototyping capabilities.
+
+**Independent Test**: Can be tested by extending a template with new handshake data and rendering in demo mode.
+
+**Acceptance Scenarios**:
+
+1. **Given** a template with handshake data, **When** I use 'set' to provide new handshake, **Then** demo rendering uses the new data.
+
+---
+
+### User Story 4 - Handle Missing Helpers Gracefully (Priority: P2)
+
+As a developer, I want clear error messages when trying to render a template with missing helpers so I can debug issues easily.
+
+**Why this priority**: Improves developer experience and debugging.
+
+**Independent Test**: Can be tested by attempting to render with missing helpers and verifying error message.
+
+**Acceptance Scenarios**:
+
+1. **Given** a template requiring a helper, **When** I render without the helper, **Then** I receive an error explaining the missing function.
+
+---
+
+### User Story 5 - Remove Routing Actions (Priority: P3)
+
+As a developer, I want routing actions removed so I can use consistent action patterns with normal render functions.
+
+**Why this priority**: Simplifies the action system and removes inconsistency.
+
+**Independent Test**: Can be tested by verifying routing actions are no longer available and alternatives work.
+
+**Acceptance Scenarios**:
+
+1. **Given** the library, **When** I check available actions, **Then** routing actions are not present.
+
+---
+
+## Edge Cases
+
+- Rendering with empty placeholders {{}} should produce {{}} - no touched placeholder, as when data is not provided;
+- Building templates with partial helpers should succeed. If helpers are not available we getting an error as a render result.
+- Extending templates with invalid placeholder definitions should fail gracefully.
+
+
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: System MUST support empty placeholders {{}} that remain untouched when no data is provided.
+- **FR-002**: System MUST support 'set' command for extending templates with new placeholders, helpers, and handshake data. Placeholders identified by position (number) or name (string); new placeholders replace existing ones. Helpers from original template preserved, new helpers can overwrite. Handshake data merged similarly.
+- **FR-003**: System MUST return a new template function from 'set' command that incorporates existing elements with the extensions. Where extensions have higher priority.
+- **FR-004**: System MUST allow building templates without all required helpers present.
+- **FR-005**: System MUST return error messages in the format "Helper '<name>' is not available" when rendering with missing helpers (can list multiple if applicable).
+- **FR-006**: System MUST remove routing actions from the action system.
+- **FR-007**: Tests MUST be updated to cover new template extension features.
+- **FR-008**: JSDoc comments MUST be updated and extended according to code changes.
+- **FR-009**: TypeScript .d.ts definitions MUST be updated to reflect new features.
+
+### Key Entities *(include if feature involves data)*
+
+- **Template**: The core template object with placeholders, helpers, and handshake.
+- **Helper**: Functions or sub-templates used in actions.
+- **Handshake**: Demo data for testing templates.
+- **Placeholder**: Dynamic parts of the template defined by {{ }}.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: Developers can create and test template extensions in under 5 minutes.
+- **SC-002**: 100% of template extension operations complete without errors.
+- **SC-003**: Error messages for missing helpers are clear and include the helper name.
+- **SC-004**: All routing actions are successfully removed without breaking existing functionality.
+- **SC-005**: Test coverage for new features reaches 90%.

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/methods/_readTemplate.js

@@ -52,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/_setupActions.js

@@ -40,14 +40,7 @@ function _setupActions ( actions, dataDeepLevel=10 ) {
                                     if ( actLevel > dataDeepLevel )  return false
                                     return true
                             }
-                    if ( act.startsWith ( '?' ) ) {   // it's a condition render action
-                                    actSetup[actLevel].push ({
-                                                      type: 'route'
-                                                    , name: act.replace ( '?', '' )
-                                                    , level: actLevel
-                                                    })
-                                    return true
-                            }
+
                     if ( act.startsWith ('^')  && act !== '^^'  ) {
                                    actSetup[actLevel].push ({
                                                           type: 'save'