@peter.naydenov/morph 3.2.0 → 3.3.1

package/src/methods/executeActions.js

@@ -0,0 +1,65 @@
+import actionRender                    from './actionRender.js'
+import actionData                      from './actionData.js'
+import actionMix                       from './actionMix.js'
+import actionExtendedRender            from './actionExtendedRender.js'
+import _defineDataType                 from "./_defineType.js"
+import { actionSave, actionOverwrite } from './actionSave.js'
+
+
+
+function executeActions({ nestedData, actSetup, helpers, original, dependencies, memory, dElement, createUseHelper }) {
+    let currentDElement = dElement;
+
+    for (let step of actSetup) {
+        let
+            { type, name, level } = step
+            , levelData = nestedData[level] || []
+            ;
+
+        // If levelData is undefined, we can't loop. But it should be [] from _defineData?
+        // nestedData[level] might be undefined?
+        // build.js said: `let levelData = nestedData[level] || []`
+
+        levelData.forEach((theData, iData) => {
+            const context = {
+                helpers
+                , original
+                , dependencies
+                , memory
+                , useHelper: createUseHelper
+                , nestedData
+                , level
+                , iData
+                , extendArguments: { dependencies, memory }
+            }
+
+            switch (type) {
+                case 'render':
+                    actionRender(step, theData, context)
+                    break
+                case 'data':
+                    actionData(step, theData, context)
+                    break
+                case 'mix':
+                    actionMix(step, theData, context)
+                    break
+                case 'save':
+                    actionSave(step, theData, context)
+                    break
+                case 'overwrite':
+                    currentDElement = actionOverwrite(step, theData)
+                    break
+                case 'route':
+                    // Deprecated, removed as per refactoring plan
+                    break
+                case 'extendedRender':
+                    actionExtendedRender(step, theData, context)
+                    break
+            }
+        })
+    }
+
+    return currentDElement
+}
+
+export default executeActions

package/src/methods/processCommands.js

@@ -0,0 +1,97 @@
+
+/**
+ * Handles debug commands for template inspection.
+ *
+ * @param {string} d - Debug instruction
+ * @param {object} context - Context object
+ * @param {object} context.handshake - Example data
+ * @param {object} context.helpers - Helper functions
+ * @param {array} context.placeholders - Placeholder definitions
+ * @param {array} context.cuts - Chopped template parts
+ * @returns {any} Debug result or error message
+ */
+function handleDebug(d, { handshake, helpers, placeholders, cuts }) {
+    switch (d) {
+        case 'raw':
+            return cuts.join('')
+        case 'demo':
+            if (!handshake) return `Error: No handshake data.`
+            return handshake // Caller handles rendering handshake
+        case 'handshake':
+            if (!handshake) return `Error: No handshake data.`
+            return structuredClone(handshake)
+        case 'helpers':
+            return Object.keys(helpers).join(', ')
+        case 'placeholders':
+            return placeholders.map(h => cuts[h.index]).join(', ')
+        case 'count':
+            return placeholders.length
+        default:
+            return `Error: Wrong instruction "${d}". Available instructions: raw, demo, handshake, helpers, placeholders, count.`
+    }
+}
+
+/**
+ * Handles the 'set' command to modify template properties.
+ *
+ * @param {object} d - Modification data
+ * @param {object} context - Context object
+ * @param {object} context.helpers - Current helper functions
+ * @param {object} context.handshake - Current handshake data
+ * @param {array} context.placeholders - Current placeholders
+ * @param {array} context.chop - Current chopped template
+ * @param {function} context.build - Build function
+ * @param {object} context.buildDependencies - Build dependencies
+ * @returns {function} Modified template function
+ */
+function handleSet(d, { helpers, handshake, placeholders, chop, build, buildDependencies }) {
+    if (typeof d !== 'object' || !d) return `Error: 'set' command requires an object with placeholders, helpers, handshake.`
+
+    const newHelpers = { ...helpers, ...(d.helpers || {}) }
+    const newHandshake = handshake ? { ...handshake, ...(d.handshake || {}) } : d.handshake || {}
+    const newChop = [...chop]
+
+    if (d.placeholders) {
+        Object.entries(d.placeholders).forEach(([k, v]) => {
+            if (!isNaN(k)) {
+                let index = placeholders[k].index;
+                newChop[index] = v
+            }
+            else {
+                let plx = placeholders.find(p => p.name === k)
+                newChop[plx.index] = v
+            }
+        })
+    }
+
+    const newTemplateStr = newChop.join('');
+    const newTpl = {
+        template: newTemplateStr,
+        helpers: newHelpers,
+        handshake: newHandshake
+    }
+
+    const result = build(newTpl, false, buildDependencies)
+    return typeof result === 'function' ? result : () => result
+}
+
+/**
+ * Handles snippets command to select specific placeholders.
+ *
+ * @param {string} command - Snippets command
+ * @param {object} snippets - Snippets mapping
+ * @returns {array|null} Selected placeholders or null
+ */
+function handleSnippets(command, snippets) {
+    if (command.includes(':')) {
+        let snippetNames = command.split(':')
+            .slice(1)[0]
+            .trim()
+            .split(',')
+            .map(t => t.trim())
+        return snippetNames.map(item => snippets[item])
+    }
+    return null // Indicates 'all snippets' or logic handled by caller
+}
+
+export { handleDebug, handleSet, handleSnippets }

package/src/methods/processPlaceholders.js

@@ -0,0 +1,155 @@
+import _defineData     from "./_defineData.js"
+import _defineDataType from "./_defineType.js"
+import _actionSupply   from "./_actionSupply.js"
+import _setupActions   from "./_setupActions.js"
+import executeActions  from "./executeActions.js"
+import render          from "./render.js"
+
+/**
+ * Processes placeholders in the template with provided data and context.
+ *
+ * @param {object} params - Parameters object
+ * @param {array} params.d - Data array to process
+ * @param {array} params.chop - Chopped template parts
+ * @param {array} params.placeholders - Placeholder definitions
+ * @param {any} params.original - Original data context
+ * @param {object} params.helpers - Helper functions
+ * @param {object} params.dependencies - Injected dependencies
+ * @param {object} params.memory - Internal memory state
+ * @param {array} params.args - Additional arguments
+ * @param {boolean} params.onlySnippets - Whether to process only snippets
+ * @returns {array} Processed template parts
+ */
+function processPlaceholders ({ d, chop, placeholders, original, helpers, dependencies, memory, args, onlySnippets }) {
+    const endData = []
+    // We need a factory for useHelper.
+    // It depends on 'currentData'. But here we are iterating 'd'.
+
+    // Helper factory to share with executeActions
+    const createUseHelperFactory = (currentData) => (targetName, targetData) => {
+        let
+            targetFn = helpers[targetName]
+            , isCompiledTemplate = targetFn && typeof targetFn === 'function' && targetFn.length >= 2
+            ;
+        if (!targetFn) return `( Error: Helper '${targetName}' is not available )`
+
+        if (isCompiledTemplate) {
+            try {
+                return targetFn('render', targetData || currentData, dependencies)
+            }
+            catch (e) {
+                return render(targetData || currentData, targetName, helpers, original, dependencies, ...args)
+            }
+        }
+        return render(targetData || currentData, targetName, helpers, original, dependencies, ...args)
+    }
+
+
+    d.forEach(dElement => {
+        let
+            cuts = structuredClone(chop)
+            , currentDElement = dElement // Can be updated by overwrite
+            ;
+
+        placeholders.forEach(holder => {
+            const
+                { index, data, action } = holder
+                , dataOnly = !action
+                , mem = structuredClone(memory)
+                ;
+            let info = currentDElement;
+
+            // Data Resolution
+            if (data && data.includes('/')) {
+                if (info.hasOwnProperty(data)) {
+                    info = info[data]
+                }
+                else {
+                    data.split('/').forEach(d => {
+                        if (info.hasOwnProperty(d)) info = info[d]
+                        else info = [] // Bug in original? info = [] then info['next'] crashes? 
+                        // Original: else info = []. 256. 
+                        // If info is [], next iteration info['key'] is undefined.
+                        // So safe.
+                    })
+                }
+            }
+            else if (data === '@all' || data === null || data === '@root') info = currentDElement
+            else if (data) info = info[data]
+
+
+            if (dataOnly) {
+                const type = _defineDataType(info);
+                switch (type) {
+                    case 'function':
+                        cuts[index] = info()
+                        break
+                    case 'primitive':
+                        cuts[index] = info
+                        break
+                    case 'array':
+                        if (_defineDataType(info[0]) === 'primitive') cuts[index] = info[0]
+                        break
+                    case 'object':
+                        if (info.text) cuts[index] = info.text
+                        break
+                }
+            }
+            else {
+                // Logic for data processing via actions
+                let
+                    { dataDeepLevel, nestedData } = _defineData(info, action)
+                    , actSetup = _actionSupply(_setupActions(action, dataDeepLevel), dataDeepLevel)
+                    ;
+
+                const createUseHelper = createUseHelperFactory(info); // use info as context? 
+                // In build.js it was `d` (the item from levelData).
+                // `executeActions` passes `theData` to `createUseHelper`.
+
+                currentDElement = executeActions({
+                    nestedData
+                    , actSetup
+                    , helpers
+                    , original
+                    , dependencies
+                    , memory
+                    , dElement: currentDElement
+                    , createUseHelper: createUseHelperFactory
+                })
+
+                // Flatten Step
+                if (nestedData instanceof Array && nestedData.length === 1 && nestedData[0] instanceof Array) nestedData = nestedData[0]
+                if (nestedData[0] == null) return
+
+                let
+                    accType = _defineDataType(nestedData[0])
+                    , fineData = nestedData[0]
+                    ;
+
+                switch (accType) {
+                    case 'primitive':
+                        if (fineData == null) return
+                        cuts[index] = fineData
+                        break
+                    case 'object':
+                        if (fineData['text'] == null) return
+                        cuts[index] = fineData['text']
+                        break
+                    case 'array':
+                        const aType = _defineDataType(fineData[0])
+                        if (aType === 'object') cuts[index] = fineData.map(x => x.text).join('')
+                        else cuts[index] = fineData.join('')
+                        break
+                }
+            }
+        }) // placeholders loop
+
+        if (onlySnippets) endData.push(placeholders.map(x => cuts[x.index]).join('<~>'))
+        else endData.push(cuts.join(''))
+
+    }) // d.forEach
+
+    return endData
+}
+
+export default processPlaceholders

package/src/methods/render.js

@@ -1,60 +1,34 @@
-import _renderHolder from "./_renderHolder.js"
+
+import _renderHolder from './_renderHolder.js'
 
 
 
 /**
- * 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
+ * Renders a helper or template with the provided data and context.
+ *
+ * @param {any} theData - The data to process.
+ * @param {string} name - The name of the helper or template to render.
+ * @param {object} helpers - Dictionary of available helpers.
+ * @param {any} original - The full original data context.
+ * @param {object} dependencies - injected dependencies.
+ * @param {...any} args - Additional arguments.
  * 
- * @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);
+ * @returns {any} The result of the rendering process, or an error string if the helper is not available.
  */
-function render ( theData, name, helpers, original, dependencies, ...args ) {
-// *** Executes rendering and return the results
-                if ( theData instanceof Object ) {   // Make sure all properties are not objects
-                        Object.entries ( theData ).forEach ( ([key, value]) => {
-                                        if ( value instanceof Object   ) theData[key] = value['text']
-                                        if ( value instanceof Array    ) theData[key] = value[0]
-                                })
-                    }
-
-                /**
-                 * 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.
-
-                 if (!helpers[name])      return `{{ Error: Helper '${name}' is not available}}`
-                 const isRenderFunction = typeof helpers[name] === 'function';   // Render could be a function or template.
-                 theData = setRenderData ( theData )
-
-                 if ( isRenderFunction )  return helpers[name]( { theData, dependencies, full:original},  ...args )
-                 else                     return _renderHolder ( helpers[name], theData   )
+function render ( theData, name, helpers, original, dependencies, ...args) {
+                const useHelper = ( targetName, targetData ) => render ( targetData || theData, targetName, helpers, original, dependencies, ...args )
+                if (!helpers[name]) return `( Error: Helper '${name}' is not available )`
+
+                const isRenderFunction = typeof helpers[name] === 'function';
+
+                if ( isRenderFunction )   return helpers[name]({ data: theData, dependencies, full: original, useHelper }, ...args)
+                else {
+                        let dataForHolder = theData
+                        if ( typeof theData !== 'object' || theData === null )   dataForHolder = { text: theData }
+                        return _renderHolder ( helpers[name], dataForHolder )
+                }
         }  // render func.
 
 
 
 export default render
-
-