Refactor - using same filterAndOrderChildren method.

Author: Dr. Safi

module/reusableNestedUnit/NestedUnit.class.js

@@ -19,22 +19,6 @@ export default ({ Superclass }) => {
             return this
         }
 
-        /**
-         * Get children corresponding to the current insertion point.
-         */
-        async filterChildrenOfCurrentInsertionPoint({
-            insertionPointKey,
-            children = this.children
-         } = {}) {
-            // [1] get children immediate & relating to this insertion position.
-            return await children.filter(child => { // filter children that correspont to the current insertionpoint.
-                return (
-                    child.insertionPosition.insertionPoint == insertionPointKey &&
-                    child.insertionPosition.insertionPathPointer == null
-                )
-            })
-        }
-
         /**
          * @description gets document from database using documentKey and populates the data to the instance.
          * 
@@ -55,16 +39,25 @@ export default ({ Superclass }) => {
          * @param {any} {insertionPointKey, insertionPath = null} 
          * @returns 
          */
-        async filterChildren({insertionPointKey}) {
-            let ownFilteredChildren = await this.filterAndModifyChildrenArray(this.children, insertionPointKey, null)
+        async filterAndOrderChildren({ insertionPointKey, children = this.children }) {
+            let ownFilteredChildren = await this.filterAndModifyChildrenArray(children, insertionPointKey, null)
             let additionalFilteredChildren = await this.filterAndModifyChildrenArray(this.additionalChildNestedUnit, insertionPointKey, this.pathPointerKey)
             return await this.mergeAndOrderChildren(ownFilteredChildren, additionalFilteredChildren);
         }
 
-        async filterAndModifyChildrenArray(childrenArray, insertionPointKey, pathPointerKey) {
-            return childrenArray.filter((child, index) => { // filter children that correspont to the current insertionpoint.
-                let result = (child.insertionPosition.insertionPoint == insertionPointKey && child.insertionPosition.insertionPathPointer == pathPointerKey)
-                // if (result) childrenArray.splice(index, 1); // was ment to increase the performance of the program, preventing rechecking of already checked array items. But it causes some issues.
+        /**
+         * Get children corresponding to the current insertion point.
+         * // Take into consideration the indirect children added from previous (inhereted) trees.
+         * // filteredTreeChildren + immediateNextChildren
+         * // let nextChildren;
+         */
+        async filterAndModifyChildrenArray(children, insertionPointKey, pathPointerKey) {
+            return children.filter((child, index) => { // filter children that correspont to the current insertionpoint.
+                let result = (
+                    child.insertionPosition.insertionPoint == insertionPointKey &&
+                    child.insertionPosition.insertionPathPointer == pathPointerKey
+                )
+                // if (result) children.splice(index, 1); // was ment to increase the performance of the program, preventing rechecking of already checked array items. But it causes some issues.
                 return result
             })
         }

module/reusableNestedUnit/implementation/condition/NestedUnit.class.js

@@ -36,33 +36,28 @@ export default ({ Superclass }) => {
                 let returnedValue;
                 // get callback from subtrees
                 for (let insertionPoint of this.insertionPoint) {
-                    returnedValue = await this.initializeInsertionPoint({ insertionPoint })
+                    // [1] get children immediate & relating to this insertion position.
+                    let children = await this.filterAndOrderChildren({ insertionPointKey: insertionPoint.key })                
+                    // let children = await this.filterChildrenOfCurrentInsertionPoint({ insertionPointKey: insertionPoint.key })
+                    returnedValue = await this.initializeInsertionPoint({ insertionPoint, children })
                     if (returnedValue) break
                 }
                 return returnedValue;
             }
 
-            async initializeInsertionPoint({insertionPoint}) {
-                let callback;
-                // [1] get children immediate & relating to this insertion position.
-                let filteredTreeChildren = await this.filterChildren({ insertionPointKey: insertionPoint.key })
-                // Take into consideration the indirect children added from previous (inhereted) trees.
-                // filteredTreeChildren + immediateNextChildren
-                // let nextChildren;
-                
+            async initializeInsertionPoint({ insertionPoint, children }) {
+                let callback;                
                 // [2] check type of subtrees execution: race first, all ... .
                 let executionTypeCallbackName;
                 switch(insertionPoint.executionType) {
                     case 'raceFirstPromise': 
                         executionTypeCallbackName = 'initializeConditionTreeInRaceExecutionType'
-                        break;
+                    break;
                     default: 
                         console.log('executionType doesn\'t match any kind.')
                 }
                 // [3] call handler on them.
-                callback = await this[executionTypeCallbackName](filteredTreeChildren)
-                // [4] return callback
-                return callback ? callback : false;
+                return await this[executionTypeCallbackName](children)
             }
 
             async initializeConditionTreeInRaceExecutionType(conditionTreeChildren) {

module/reusableNestedUnit/implementation/middleware/NestedUnit.class.js

@@ -38,10 +38,7 @@ export default ({ Superclass }) => {
                 // get callback from subtrees
                 if(this.insertionPoint) {
                     for (let insertionPoint of this.insertionPoint) {
-                        let children = await this.filterChildrenOfCurrentInsertionPoint({
-                            insertionPointKey: insertionPoint.key,
-                            children: this.children
-                        })
+                        let children = await this.filterAndOrderChildren({ insertionPointKey: insertionPoint.key })                                        
                         let subsequentArray = await this.initializeInsertionPoint({ insertionPoint, children })
                         if(array.length != 0) {
                             await Array.prototype.push.apply(array, subsequentArray)

module/reusableNestedUnit/implementation/template/NestedUnit.class.js

@@ -40,18 +40,19 @@ export default ({ Superclass }) => {
                 let view = {}
                 if(this.insertionPoint) {
                     for (let insertionPoint of this.insertionPoint) {
+                        let children = await this.filterAndOrderChildren({ insertionPointKey: insertionPoint.key })                                        
                         if(!(insertionPoint.name in view)) view[insertionPoint.name] = []
-                        Array.prototype.push.apply( view[insertionPoint.name], await this.initializeInsertionPoint({ insertionPoint }) )
+                        Array.prototype.push.apply( 
+                            view[insertionPoint.name],
+                            await this.initializeInsertionPoint({ insertionPoint, children }) 
+                        )
                     }
                 }
                 return view;
             }
 
-            async initializeInsertionPoint({insertionPoint}) {
-                // [1] get children immediate & relating to this insertion position.
-                let filteredChildren = this.children.filter(object => { // filter children that correspont to the current insertionpoint.
-                    return (object.insertionPosition.insertionPoint == insertionPoint.key && object.insertionPosition.insertionPathPointer == null)
-                })
+            async initializeInsertionPoint({ insertionPoint, children }) {
+
                 // [2] check type of subtrees execution: race first, all ... .
                 let executionTypeCallbackName;
                 switch(insertionPoint.executionType) {
@@ -62,7 +63,7 @@ export default ({ Superclass }) => {
                         console.log(`"${insertionPoint.executionType}" executionType doesn\'t match any kind (in function called initializeInsertionPoint of NestedUnit.class.js file).`)
                 }
                 // [3] call handler on them & and return rendered template array corresponding to the specifc insertionPoint.
-                return await this[executionTypeCallbackName](filteredChildren)
+                return await this[executionTypeCallbackName](children)
             }
 
             async initializeTreeInChronologicalSequence(treeChildren) {