@peter.naydenov/morph 3.3.1 → 3.3.3

package/src/methods/_chopTemplates.js

@@ -1,81 +1,74 @@
 /**
  * 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}}!');
+ * // Returns: ['Hello ', '{{name}}', '!']
  */
 function _chopTemplate ( settings ) {
-    return function _chopTemplate ( text ) {
+    return function chop ( text ) {
         const { TG_PRX, TG_SFX, TG_SIZE_P, TG_SIZE_S } = settings;
-        let 
-            start      // placeholder start
-          , end        // placeholder end
-          , checkPoint // check 
-          , res = []   // template result array
-          ;
-    
-        if ( typeof(text) != 'string' ) return showError( 'notAString' ) // Template is not a string
-        if ( text.length == 0 ) return []
-    
-        start = text.indexOf ( TG_PRX )
-        if ( 0 < start )  res.push ( text.slice(0, start) )
-        if ( -1 == start ) {
-                    res.push( text  )
-                    return res;
-             }
-        else {
-                    checkPoint = text.indexOf ( TG_PRX, start+TG_SIZE_P )
-                    end = text.indexOf( TG_SFX )
-    
-                    if ( end == -1   ) return showError('missingClosing') // Placeholder with missing closing tags
-                    if ( end < start ) return showError('closedBeforeOpened') // Placeholder closing tags without starting ones
-                    else               end += TG_SIZE_S 
-    
-                    if ( checkPoint != -1 && checkPoint < end ) {
-                         return showError('newBeforeClosed') // New placeholder before first ends
-                       }
-    
-                    res.push( text.slice(start,end) )
-                    let nextText = text.slice (end)
-                    let additional = _chopTemplate ( nextText )
-                    return res.concat ( additional )
-             }
-    }} // chopTemplate func.
-    
-    
-    
-    /**
+
+        if ( typeof text != 'string' )   return showError ( 'notAString' )
+        if ( text.length == 0        )   return []
+
+        const start = text.indexOf ( TG_PRX )
+        if ( start == -1 )   return [ text ]   // No placeholders left
+
+        const res = []
+        if ( start > 0 )   res.push ( text.slice ( 0, start ))
+
+        let end = text.indexOf ( TG_SFX )
+        const nextStart = text.indexOf ( TG_PRX, start + TG_SIZE_P )
+
+        if ( end == -1     )   return showError ( 'missingClosing' )
+        if ( end < start   )   return showError ( 'closedBeforeOpened' )
+        end += TG_SIZE_S
+
+        if ( nextStart != -1  &&  nextStart < end )   return showError ( 'newBeforeClosed' )
+
+        res.push ( text.slice ( start, end ))
+
+        const rest = chop ( text.slice ( end ))   // Continue with the rest of the text
+        if ( typeof rest === 'string' )   return rest   // Parse error found deeper in the template. Propagate it.
+        return res.concat ( rest )
+    }
+} // _chopTemplate func.
+
+
+
+/**
  * 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.`
-                  case 'missingClosing':
-                            return `Error: Placeholder with missing closing tag.`
-                  case 'closedBeforeOpened':
-                            return `Error: Placeholder closing tag without starting one.`
-                  case 'newBeforeClosed':
-                            return `Error: Nested placeholders. Close placeholder before open new one.`
-                  default: 
-                            return `Error: Unknown template error.`
-                }
-    } // showError func.
-    
-    
-    
-    export default _chopTemplate
-    
-    
+function showError ( type ) {
+    switch ( type ) {
+        case 'notAString':
+                return `Error: Template is not a string.`
+        case 'missingClosing':
+                return `Error: Placeholder with missing closing tag.`
+        case 'closedBeforeOpened':
+                return `Error: Placeholder closing tag without starting one.`
+        case 'newBeforeClosed':
+                return `Error: Nested placeholders. Close placeholder before open new one.`
+        default:
+                return `Error: Unknown template error.`
+    }
+} // showError func.
+
+
+
+export default _chopTemplate
+
+

package/src/methods/_setupActions.js

@@ -16,25 +16,18 @@
  * //            2: [] }
  */
 function _setupActions ( actions, dataDeepLevel=10 ) {
-    let 
+    let
       actSetup = {}
-    , actionList = [...actions]
     , actLevel = 0
-    , i = 0
-    , countHashes = 0
     ;
-    
-    actionList.forEach ( action => {   if ( action === '#' )  countHashes++   })
-    if ( countHashes < dataDeepLevel )   console.error ( `Error: Not enough level markers (#) for data with depth level ${dataDeepLevel}. Found ${countHashes} level markers in actions: ${actions.join(', ')}` )
-
-    do {
-            actSetup[i] = []
-            i++
-    } while ( i <= dataDeepLevel )
 
+    const countHashes = actions.filter ( action => action === '#' ).length
+    if ( countHashes < dataDeepLevel )   console.error ( `Error: Not enough level markers (#) for data with depth level ${dataDeepLevel}. Found ${countHashes} level markers in actions: ${actions.join(', ')}` )
 
+    for ( let i = 0; i <= dataDeepLevel; i++ )   actSetup[i] = []
 
-    actionList.every ( act => {
+    // 'every' works as forEach with a break: returning false stops on too many '#'
+    actions.every ( act => {
                     if ( act === '#' ) {   // it's a change level action
                                     actLevel++
                                     if ( actLevel > dataDeepLevel )  return false
@@ -91,7 +84,7 @@ function _setupActions ( actions, dataDeepLevel=10 ) {
                                             , level: actLevel
                                             })
             return true
-            }) // actionList every
+            }) // actions every
     return actSetup
 } // _setupActions func.
 

package/src/methods/actionData.js

@@ -1,30 +1,44 @@
 import _defineDataType from "./_defineType.js"
 
-function actionData({ name }, levelData, { helpers, extendArguments, nestedData, level, useHelper }) {
-    const theData = levelData
-    let dataType = _defineDataType(theData)
 
-    switch (dataType) {
+
+/**
+ * Action 'data' ('>'). Calls the named helper to transform the data before
+ * rendering. The result replaces the level data.
+ *
+ * Function data provides its value by being called. The uncalled item stays
+ * available to the helper as the 'full' argument.
+ *
+ * @param {object} step - Action step: { name } is the helper name
+ * @param {any} theData - Current data item from the level slice
+ * @param {object} context - Execution context (see executeActions.js)
+ */
+function actionData ({ name }, theData, { helpers, extendArguments, nestedData, level, useHelper }) {
+    const callHelper = ( data, full, uhContext ) => helpers[name] ({ data, ...extendArguments, full, useHelper: useHelper ( uhContext ) })
+
+    switch ( _defineDataType ( theData )) {
         case 'array':
-            theData.forEach((d, i) => {
-                const localUseHelper = useHelper(d);
-                theData[i] = (d instanceof Function) ? helpers[name]({ data: d(), ...extendArguments, full: d, useHelper: localUseHelper }) : helpers[name]({ data: d, ...extendArguments, full: d, useHelper: localUseHelper })
-            })
-            break
+                theData.forEach ( ( d, i ) => {
+                        const value = ( d instanceof Function )  ?  d ()  :  d
+                        theData[i] = callHelper ( value, d, d )
+                    })
+                break
         case 'object':
-            const uhObj = useHelper(theData);
-            nestedData[level] = [helpers[name]({ data: theData, ...extendArguments, full: theData, useHelper: uhObj })]
-            break
-        case 'function':
-            const fnData = theData();
-            const uhFn = useHelper(fnData);
-            nestedData[level] = [helpers[name]({ data: fnData, ...extendArguments, full: theData, useHelper: uhFn })]
-            break
+                nestedData[level] = [ callHelper ( theData, theData, theData ) ]
+                break
+        case 'function': {
+                const value = theData ()
+                nestedData[level] = [ callHelper ( value, theData, value ) ]
+                break
+            }
         case 'primitive':
-            const uhPrim = useHelper(theData);
-            nestedData[level] = helpers[name]({ data: theData, ...extendArguments, full: theData, useHelper: uhPrim })
-            break
+                nestedData[level] = callHelper ( theData, theData, theData )
+                break
     } // switch dataType
-}
+} // actionData func.
+
+
 
 export default actionData
+
+

package/src/methods/actionExtendedRender.js

@@ -1,28 +1,27 @@
-import _defineDataType from "./_defineType.js"
+/**
+ * Action 'extendedRender' ('+'). Runs the named helper over every item of the
+ * root level data (nestedData[0]) and replaces the items with the results.
+ *
+ * Useful when a placeholder needs to post-process the whole data list after
+ * the deeper levels are already rendered. Missing helpers are silently ignored.
+ *
+ * @param {object} step - Action step: { name } is the helper name
+ * @param {any} theData - Current data item (unused - this action works on the root level)
+ * @param {object} context - Execution context (see executeActions.js)
+ */
+function actionExtendedRender ({ name }, theData, { helpers, extendArguments, useHelper, nestedData }) {
+    const helper = helpers[name]
 
-function actionExtendedRender({ name }, levelData, { helpers, extendArguments, nestedData, level, useHelper }) {
-    // levelData is unused?
-    // build.js used `nestedData[0]`.
-    // "nestedData[0].forEach((d, i) => {"
-    // "const uh = createUseHelper(d);"
-    // "nestedData[0][i] = helpers[name]({ data: d, ...extendArguments, full: d, useHelper: uh })"
+    if ( typeof helper !== 'function' )      return
+    if ( !Array.isArray ( nestedData[0] ))   return
 
-    // This seems to assume extendedRender operates on ROOT data (nestedData[0])?
-    // Yes, `nestedData[0]` is typically the initial data list.
+    nestedData[0].forEach ( ( d, i ) => {
+            nestedData[0][i] = helper ({ data: d, ...extendArguments, full: d, useHelper: useHelper ( d ) })
+        })
+} // actionExtendedRender func.
 
-    const isValid = typeof helpers[name] === 'function';
 
-    if (isValid) {
-        if (nestedData[0] && Array.isArray(nestedData[0])) {
-            nestedData[0].forEach((d, i) => {
-                const uh = useHelper(d);
-                nestedData[0][i] = helpers[name]({ data: d, ...extendArguments, full: d, useHelper: uh })
-            })
-        }
-    }
-    else {
-        // TODO: Error...
-    }
-}
 
 export default actionExtendedRender
+
+

package/src/methods/actionMix.js

@@ -1,61 +1,59 @@
 import _defineDataType from "./_defineType.js"
 import walk from '@peter.naydenov/walk'
 
-function actionMix({ name }, levelData, { helpers, extendArguments, nestedData, level, useHelper }) {
-    const theData = levelData
-    let dataType = _defineDataType(theData)
 
-    if (name === '') {   // when is anonymous mixing action
-        switch (dataType) {
-                    case 'object':
-                        let kTest = Object.keys(theData).find(k => k.includes('/'));   // Check if keys are breadcrumbs
-                        if (kTest) Object.entries(theData).forEach(([k, v]) => nestedData[level][k] = v['text'])
-                        else nestedData[level] = theData['text']
-                        for (let i = level - 1; i >= 0; i--) {
-                                nestedData[i] = walk({ data: nestedData[i], objectCallback: check })
+
+/**
+ * Action 'mix' ('[]'). Merges the level data into a single value.
+ *
+ * Anonymous mix ('[]', no helper name):
+ *   - array  : joins all items (or their 'text' property) into one string;
+ *   - object : publishes the 'text' results to the upper data levels,
+ *              matching values by their breadcrumb keys.
+ *
+ * Named mix ('[]helperName'): the helper receives the data and produces
+ * the merged value itself.
+ *
+ * @param {object} step - Action step: { name } is the helper name ('' for anonymous mix)
+ * @param {any} theData - Current data item from the level slice
+ * @param {object} context - Execution context (see executeActions.js)
+ */
+function actionMix ({ name }, theData, { helpers, extendArguments, nestedData, level, useHelper }) {
+
+    if ( name === '' ) {   // Anonymous mixing action
+            switch ( _defineDataType ( theData )) {
+                case 'object': {
+                        const hasBreadcrumbKeys = Object.keys ( theData ).some ( k => k.includes ( '/' ))
+                        if ( hasBreadcrumbKeys )   Object.entries ( theData ).forEach ( ([ k, v ]) => nestedData[level][k] = v['text'] )
+                        else                       nestedData[level] = theData['text']
+
+                        // Publish up: replace matching breadcrumb values on every level above
+                        const check = ({ value, breadcrumbs }) => nestedData[level][breadcrumbs]  ?  nestedData[level][breadcrumbs]  :  value
+                        for ( let i = level - 1; i >= 0; i-- ) {
+                                nestedData[i] = walk ({ data: nestedData[i], objectCallback: check })
                             }
-                        function check({ value, breadcrumbs }) {
-                                if (nestedData[level][breadcrumbs]) return nestedData[level][breadcrumbs]
-                                return value
-                            } // check func.
                         break
-                    case 'array':
-                        theData.forEach((x, i) => {
-                                if (i > 0) {
-                                        let xType = _defineDataType(x);
-                                        if (x == null) return
-                                        if (xType === 'object') theData[0] += `${x.text}`
-                                        else theData[0] += `${x}`
-                                        theData.toSpliced(i, 1)
-                                    }
-                                else {
-                                        let xxType = _defineDataType(x);
-                                        theData[0] = ''
-                                        if (xxType === null) return
-                                        else if (xxType === 'object') theData[0] = `${x.text}`
-                                        else theData[0] = `${x}`
-                                    }
-                            }) // forEach theData
+                    }
+                case 'array': {
+                        const asText = ( x ) => ( _defineDataType ( x ) === 'object' )  ?  `${x.text}`  :  `${x}`
+                        theData[0] = theData.map ( x => ( x == null ) ? '' : asText ( x )).join ( '' )
                         theData.length = 1
                         break
-            } // switch dataType
-        } // if name === ''
-    else {
-                const dType = _defineDataType ( theData ); // 'd' in build.js was 'd' from loop, here 'theData'
-                const localUseHelper = useHelper ( theData );
-                let val = helpers[name]({ data: theData, ...extendArguments, full: theData, useHelper: localUseHelper }); // 'full: d' in build.js, here 'theData'
-                let valType = _defineDataType(val);
+                    }
+                } // switch dataType
+        }
+    else {   // Named mixing action - the helper produces the merged value
+            const val = helpers[name] ({ data: theData, ...extendArguments, full: theData, useHelper: useHelper ( theData ) })
 
-                theData.forEach((x, i) => theData.splice(i, 1))
-                theData.length = 0
-                switch (valType) {
-                            case 'primitive':
-                                theData[0] = val
-                                break
-                            case 'array':
-                                theData.push(...val)
-                                break
-                    } // switch valType
+            theData.length = 0
+            switch ( _defineDataType ( val )) {
+                case 'primitive':
+                        theData[0] = val
+                        break
+                case 'array':
+                        theData.push ( ...val )
+                        break
+                } // switch valType
         }
 } // actionMix func.
 

package/src/methods/actionRender.js

@@ -1,86 +1,54 @@
 import _defineDataType from "./_defineType.js"
 import render from "./render.js"
 
-function actionRender({ name }, levelData, { helpers, original, dependencies, useHelper, extendArguments, nestedData, level, iData }) {
-    /**
-     * logic from build.js 'render' case
-     * levelData is the array we are iterating (nestedData[level] or similar)
-     * But wait, build.js iterates levelData.
-     * "levelData.forEach((theData, iData) => {"
-     * So actionRender receives a SINGLE item?
-     * No, existing logic handles 'array' dataType inside the switch.
-     * But the loop inside build.js ALREADY iterates levelData.
-     * Line 276: `levelData.forEach((theData, iData) => { ... switch(type) ... })`
-     * So 'theData' is a single item from the level.
-     * BUT 'dataType' switch inside handles 'array'?
-     * _defineDataType(theData).
-     * If 'theData' is array, it iterates it.
-     * Yes.
-     */
 
-    const theData = levelData
-    let dataType = _defineDataType(theData)
-    const isRenderFunction = typeof helpers[name] === 'function';
 
-    switch (dataType) {
-        case 'array':
-            if (isRenderFunction) {
-                theData.forEach((d, i) => {
-                    if (d == null) return
-                    const dType = _defineDataType(d);
-                    // useHelper is specialized for 'd' ??
-                    // in build.js: const useHelper = createUseHelper(d);
-                    // access to 'createUseHelper' needed?
-                    // Yes.
-                    // So we pass 'createUseHelper' factory, not the instance?
-                    // Or we pass the instance if it was already created?
-                    // In build.js loop: "const useHelper = createUseHelper(d);" happens INSIDE case 'route'/'data'/'render' loops usually.
-                    // But here we are inside case 'render'.
-                    // So we need 'createUseHelper' passed in context.
-
-                    const localUseHelper = useHelper(d)
-                    const text = helpers[name]({ data: d, ...extendArguments, full: original, useHelper: localUseHelper });
+/**
+ * Action 'render'. Renders the current data item with the named helper and
+ * writes the result back into the data slice.
+ *
+ * Write-back rules:
+ *   - primitive results replace the data item;
+ *   - object data receives the result as its 'text' property;
+ *   - a null result marks the item as null, so later steps can skip it.
+ *
+ * @param {object} step - Action step: { name } is the helper name
+ * @param {any} theData - Current data item from the level slice
+ * @param {object} context - Execution context (see executeActions.js)
+ */
+function actionRender ({ name }, theData, { helpers, original, dependencies, useHelper, extendArguments, nestedData, level }) {
+    const
+          dataType = _defineDataType ( theData )
+        , isRenderFunction = typeof helpers[name] === 'function'
+        , callHelper = ( data, full ) => helpers[name] ({ data, ...extendArguments, full, useHelper: useHelper ( data ) })
+        ;
 
-                    if (text == null) theData[i] = null
-                    if (dType === 'object') d['text'] = text
-                    else theData[i] = text
-                })
-            }
-            else {
-                theData.forEach((d, i) => {
-                    if (d == null) return
-                    const
-                        dType = _defineDataType(d)
-                        , text = render(d, name, helpers, original, dependencies)
-                        ;
-                    if (text == null) theData[i] = null
-                    else if (dType === 'object') d['text'] = text
-                    else theData[i] = text
-                })
-            }
-            break
+    switch ( dataType ) {
+        case 'array':
+                theData.forEach ( ( d, i ) => {
+                        if ( d == null )   return
+                        const text = isRenderFunction  ?  callHelper ( d, original )  :  render ( d, name, helpers, original, dependencies )
+                        if ( text == null )                              theData[i] = null
+                        else if ( _defineDataType ( d ) === 'object' )   d['text'] = text
+                        else                                             theData[i] = text
+                    })
+                break
         case 'function':
-            const fD = theData();
-            const useHelperFn = useHelper(fD);
-            nestedData[level] = helpers[name]({ data: fD, ...extendArguments, full: theData, useHelper: useHelperFn })
-            break
+                nestedData[level] = callHelper ( theData (), theData )
+                break
         case 'primitive':
-            if (isRenderFunction) {
-                const uhPrim = useHelper(theData);
-                nestedData[level] = helpers[name]({ data: theData, ...extendArguments, full: theData, useHelper: uhPrim })
-            }
-            else nestedData[level] = render(theData, name, helpers, original, dependencies)
-            break
+                if ( isRenderFunction )   nestedData[level] = callHelper ( theData, theData )
+                else                      nestedData[level] = render ( theData, name, helpers, original, dependencies )
+                break
         case 'object':
-            if (isRenderFunction) {
-                const uhO = useHelper(theData);
-                nestedData[level][iData]['text'] = helpers[name]({ data: theData, ...extendArguments, full: theData, useHelper: uhO })
-            }
-            else {
-                theData['text'] = render(theData, name, helpers, original, dependencies)
-            }
-            break
-    } // switch renderDataType 
-}
+                if ( isRenderFunction )   theData['text'] = callHelper ( theData, theData )
+                else                      theData['text'] = render ( theData, name, helpers, original, dependencies )
+                break
+    } // switch dataType
+} // actionRender func.
+
+
 
 export default actionRender
+
+