qcobjects 2.4.50 → 2.4.52

package/QCObjects.js

@@ -1310,9 +1310,12 @@
     return shortCode;
   };
   var uniqueId = shortCode;
+  Class("InheritClass", class {}, {});
+
+  class Processor extends ClassFactory("InheritClass") {
+    component = null;
 
-  Class("Processor", {
-    processors: {
+    static processors= {
       "config"(arg) {
         return _top.CONFIG.get(arg, "");
       },
@@ -1322,48 +1325,63 @@
       "global"(arg) {
         return (typeof global !== "undefined") ? (global[arg]) : ("");
       }
-    },
-    setProcessor(_proc_) {
+    };
+    static setProcessor(_proc_) {
       if (typeof _proc_ === "function" && _proc_.name !== "") {
         this.processors[_proc_.name] = _proc_;
       }
-    },
-    execute(processorName, args) {
-      let processorHandler = this;
-      return processorHandler.processors[processorName].apply(processorHandler, args.split(","));
-    },
-    process(template) {
+    }
+    
+    constructor (){
+      super(...arguments);
+      this.processors = Processor.processors;
+      this.process = Processor.process.bind(this);
+      this.processObject = Processor.processObject.bind(this);
+      this.setProcessor = Processor.setProcessor.bind(this);
+    }
+
+    execute(component,processorName, args) {
+      var processorHandler = this;
+      var component = processorHandler.component;
+      return processorHandler.processors[processorName].bind(processorHandler).apply(processorHandler,[component,...args.split(",")]);
+    }
+
+    static process(template, component = null) {
+      var processorHandler = this;
       if (typeof template === "string") {
-        let processorHandler = this;
         Object.keys(processorHandler.processors).map(function (funcName) {
           [...template.matchAll(new RegExp("\\$" + funcName + "\\((.*)\\).*", "g"))].map(
             function (procesorMatch) {
               var match0 = `$${funcName}(${procesorMatch[1]})`;
-              template = template.replace(match0, processorHandler.execute.call(processorHandler, funcName, procesorMatch[1]));
+              template = template.replace(match0, processorHandler.execute.bind(processorHandler).call(processorHandler, component, funcName, procesorMatch[1]));
             }
           );
         });
       }
       return template;
-    },
-    processObject(obj) {
-      let __instance__ = this;
+    }
+
+    static processObject(obj, component = null) {
+      var __instance__ = this;
       if (typeof obj === "object") {
         Object.keys(obj).map(
           function (_k) {
             if (typeof obj[_k] === "object" && !obj[_k].hasOwnProperty.call(obj[_k], "call")) {
-              obj[_k] = __instance__.processObject(obj[_k]);
+              obj[_k] = __instance__.processObject.bind(__instance__)(obj[_k], component);
             } else if (typeof obj[_k] === "string") {
-              obj[_k] = __instance__.process(obj[_k]);
+              obj[_k] = __instance__.process.bind(__instance__)(obj[_k], component);
             }
           }
         );
       } else if (typeof obj === "string") {
-        obj = __instance__.process(obj);
+        obj = __instance__.process.bind(__instance__)(obj, component);
       }
       return obj;
     }
-  });
+
+  }
+  RegisterClass(Processor,"com.qcobjects");
+
 
   class ConfigSettings {
     static _instance = null;
@@ -1826,7 +1844,6 @@
   } else {
     global.onload = _Ready;
   }
-  Class("InheritClass", class {}, {});
 
   /**
    * Dynamic Data Objects Class
@@ -1917,8 +1934,13 @@
   }
   Export(DDO);
 
-  Class("DefaultTemplateHandler", Object, {
-    template: "",
+  class DefaultTemplateHandler {
+    template= "";
+    __definition = {};
+    constructor ({component, template}){
+      this.component = component;
+      this.template = template;
+    }
     assign(data) {
       var templateInstance = this;
       if (typeof templateInstance.component === "undefined") {
@@ -1928,26 +1950,36 @@
         throw new Error("DefaultTemplateHandler.assign: component.processorHandler is undefined");
       }
       var processorHandler = templateInstance.component.processorHandler;
+      processorHandler.component = templateInstance.component;
       var parsedAssignmentText = (typeof templateInstance.template !== "undefined") ? (templateInstance.template) : ("");
       if (typeof data === "object") {
         [...Object.keys(data)].map(function (k) {
           var _value = data[k];
           if (typeof _value === "string" || typeof _value === "number" || (!isNaN(_value))) {
             try {
-              _value = ClassFactory("Processor").processObject.call(processorHandler, _value);
+              _value = ClassFactory("Processor").processObject.bind(processorHandler).call(processorHandler, _value, templateInstance.component);
               parsedAssignmentText = parsedAssignmentText.replace((new RegExp(`{{${k}}}`, "g")), _value);
             } catch (e) {
-              logger.warn(e);
+              logger.warn(`${templateInstance.component.name} could not parse processors.`);
+              throw Error (`${templateInstance.component.name} could not parse processors. Reason: ${e.message}`);
             }
           }
         });
       } else {
         logger.debug(`${templateInstance.component.name}.data is not an object`);
       }
-      parsedAssignmentText = ClassFactory("Processor").processObject.call(processorHandler, parsedAssignmentText);
+      try {
+        parsedAssignmentText = ClassFactory("Processor").processObject.call(processorHandler, parsedAssignmentText, templateInstance.component);
+      }catch (e){
+        logger.warn(`${templateInstance.component.name} could not parse processors.`);
+        throw Error (`${templateInstance.component.name} could not parse processors. Reason: ${e.message}`);
+      }
       return parsedAssignmentText;
     }
-  });
+    
+  }
+  DefaultTemplateHandler.__definition = {};
+  RegisterClass(DefaultTemplateHandler,"com.qcobjects");
 
   var __routing_params__ = function (routing, routingPath) {
     let standardRoutingPath = routing.path.replace(/{(.*?)}/g, "(?<$1>.*)"); //allowing {param}
@@ -2259,13 +2291,19 @@
               request,
               service
             }) {
-              var serviceResponse = service.template;
+              var serviceResponse;
+              if (typeof service.JSONresponse !== "undefined" && service.JSONresponse !== null){
+                serviceResponse = service.JSONresponse;
+              } else {
+                serviceResponse = service.template;
+              }
               if (_response_to_data_) {
                 if (typeof data === "object" && typeof serviceResponse === "object") {
                   data = Object.assign(data, serviceResponse);
                 } else {
                   data = serviceResponse;
                 }
+                component.data = data;
               }
               component.serviceInstance = serviceInstance;
               component.serviceData = data;
@@ -2621,7 +2659,9 @@
                 break;
               case (_component.get("tplsource") === "inline"):
                 logger.debug("Component " + _component.name + " has specified template-source=inline, so it is assumed that template is already declared");
-                _component.feedComponent();
+                (async function (_component){
+                  _component.feedComponent.bind(_component)();
+                })(_component);
                 var standardResponse = {
                   request: null,
                   component: _component
@@ -2833,6 +2873,7 @@
             component: _self,
             template: value
           });
+          templateInstance.component = _self;
           var selfData = _self.data;
           if (Object.hasOwnProperty.call(_self, "assignRoutingParams") && _self.assignRoutingParams) {
             try {
@@ -4586,7 +4627,7 @@
   // Set Processors
   (function (_top) {
 
-    let mapper = function (componentName, valueName) {
+    let mapper = function (componentInstance,componentName, valueName) {
       /*
        * Mapper processor
        * @usage
@@ -4597,16 +4638,19 @@
        * the component instance, the data object or a global value
        */
 
-
+      var self = this;
+      if (typeof componentInstance === "undefined" || componentInstance === null){
+        throw Error (`mapper.${componentName}.${valueName} does not have a component instance or it is null.`);
+      }
       let globalValue = _top.global.get(valueName);
-      let componentValue = this.component.get(valueName);
-      let dataValue = this.component.data[valueName];
+      let componentValue = componentInstance.get(valueName);
+      let dataValue = componentInstance.data[valueName];
       let list = (typeof dataValue !== "undefined") ? (dataValue) : ((typeof componentValue !== "undefined") ? (componentValue) : (globalValue));
       let listItems = "";
       if (typeof list !== "undefined" && typeof list["map"] !== "undefined") {
         listItems = list.map(function (element) {
-          let dataItems = [...Object.keys(element)].map(k => ` data-${k}="${element[k].toString()}"`).join("");
-          return `<component name="${componentName}" ${dataItems} ></component>`;
+          let dataItems = [...Object.keys(element)].map(k => ` data-${k}="${(typeof element[k] !== "undefined" && element[k] !== null)?(element[k].toString()):("")}"`).join("");
+          return `<quick-component name="${componentName}" ${dataItems} ></quick-component>`;
         }).join("");
       } else {
         logger.debug(`${componentName}.${valueName} does not have a map property`);
@@ -4615,7 +4659,7 @@
     };
     ClassFactory("Processor").setProcessor(mapper);
 
-    let layout = function (layoutname, cssfile) {
+    let layout = function (componentInstance, layoutname, cssfile) {
       /*
        * Layout processor
        * @usage
@@ -4660,7 +4704,7 @@
        * Returns a component tag declaration like:
        * <component name=<name> ...></component>
        */
-      let arg = [...arguments].map(function (a) {
+      let arg = [...arguments].slice(1).map(function (a) {
         return {
           [a.split("=")[0]]: a.split("=")[1]
         };
@@ -4675,7 +4719,31 @@
 
     ClassFactory("Processor").setProcessor(component);
 
-    let repeat = function (length, text) {
+    let quick_component = function () {
+      /*
+       * component processor
+       * @usage
+       *        $quick_component(name=<name>, componentClass=<componentClass>, ...)
+       * Returns a component tag declaration like:
+       * <quick-component name=<name> ...></quick-component>
+       */
+      let arg = [...arguments].slice(1).map(function (a) {
+        return {
+          [a.split("=")[0]]: a.split("=")[1]
+        };
+      }).reduce(function (k1, k2) {
+        return Object.assign(k1, k2);
+      });
+      let attrs = [...Object.keys(arg)].map(function (a) {
+        return `${a}=${arg[a]}`;
+      }).join(" ");
+      return `<quick-component ${attrs}></quick-component>`;
+    };
+
+    ClassFactory("Processor").setProcessor(quick_component);
+
+
+    let repeat = function (componentInstance, length, text) {
       /*
        * Repeat processor
        * @usage

package/VERSION

@@ -1 +1 @@
-2.4.50
+2.4.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qcobjects",
-  "version": "2.4.50",
+  "version": "2.4.52",
   "description": "QCObjects is an Open-source framework that empowers full-stack developers to make micro-services and micro-frontends into an N-Tier architecture.",
   "main": "QCObjects.js",
   "license": "LGPL-3.0",