qcobjects 2.4.107-ts → 2.4.108-ts

package/src/componentLoader.ts

@@ -0,0 +1,252 @@
+import { IComponent, TCacheController } from "types";
+import { asyncLoad } from "./asyncLoad";
+import { ComplexStorageCache } from "./ComplexStorageCache";
+import { _DataStringify } from "./DataStringify";
+import { logger } from "./Logger";
+import { _require_, is_phonegap, isBrowser } from "./platform";
+import { _top } from "./top";
+
+/**
+ * Loads a simple component from a template
+ *
+ * @author: Jean Machuca <correojean@gmail.com>
+ * @param component a Component object
+ */
+export const componentLoader = function (component: IComponent, _async: boolean):Promise<any> {
+    let __promise__: Promise<any>;
+    const _componentLoaderInBrowser = function (component: IComponent) {
+        __promise__ = new Promise(function (resolve, reject) {
+            const _promise = component.__promise__;
+            const container = (Object.hasOwn(component, "container") && typeof component.container !== "undefined" && component.container !== null) ? (component.container) : (component.body);
+            if (container !== null) {
+                const _feedComponent_ = function (component: { feedComponent: () => void; }) {
+                    component.feedComponent();
+                    const standardResponse = {
+                        "request": xhr,
+                        component
+                    };
+                    resolve.call(_promise, standardResponse);
+                };
+                logger.debug("LOADING COMPONENT DATA {{DATA}} FROM {{URL}}".replace("{{DATA}}", _DataStringify(component.data)).replace("{{URL}}", component.url));
+
+                const _componentLoaded = function () {
+                    const successStatus = (is_file) ? (0) : (200);
+                    if (xhr.status === successStatus) {
+                        const response = xhr.responseText;
+                        logger.debug("Data received {{DATA}}".replace("{{DATA}}", _DataStringify(response)));
+                        logger.debug("CREATING COMPONENT {{NAME}}".replace("{{NAME}}", component.name));
+                        component.template = response;
+                        if (component.cached && (typeof cache !== "undefined")) {
+                            cache.save(component.name, component.template);
+                        }
+                        _feedComponent_(component);
+                    } else {
+                        const standardResponse = {
+                            "request": xhr,
+                            component
+                        };
+                        reject.call(_promise, standardResponse);
+
+                    }
+                };
+                if (typeof component.template === "string" && component.template !== "") {
+                    // component already has a template it does not need to be reloaded
+                    _feedComponent_(component);
+                } else {
+                    var is_file = !!(component.url.startsWith("file:"));
+                    var xhr = new XMLHttpRequest();
+                    if (!is_file) {
+                        try {
+                            logger.debug("Calling the url of component in async mode.");
+                            xhr.open(component.method, component.url, true);
+                        } catch (e:any) {
+                            logger.debug(`An error ocurred: ${e}.`);
+                            logger.debug("Last try has failed... The component cannot be loaded.");
+                        }
+                    } else {
+                        if ("fetch" in _top) {
+                            logger.debug("I can use fetch...");
+                            logger.debug("It is a file to be loaded, so I will try to use fetch");
+                            fetch(component.url).then(response => {
+                                logger.debug("I got a response from fetch, so I'll feed the component");
+                                response.text().then(text => {
+                                    component.template = text;
+                                    _feedComponent_(component);
+                                })
+                                .catch((e:any) => {throw new Error (`An error ocurred: ${e}`);});
+                            }).catch ((e:any) => {throw new Error (`An error ocurred: ${e}`);});
+                        }
+                    }
+                    if (!is_phonegap && !is_file) {
+                        xhr.setRequestHeader("Content-Type", "text/html");
+                    }
+                    if (!is_file) {
+                        xhr.onload = _componentLoaded;
+                    }
+                    const _directLoad = function (is_file: boolean) {
+                        is_file = !((typeof is_file === "undefined" || !is_file));
+                        logger.debug("SENDING THE NORMAL REQUEST  ");
+                        if (is_file) {
+                            if (!("fetch" in _top)) {
+                                logger.debug("I have to try to load the file using xhr...  ");
+                                xhr.send(null);
+                                if (xhr.status === XMLHttpRequest.DONE) {
+                                    _componentLoaded();
+                                }
+                            }
+                        } else {
+                            logger.debug("Trying to send the data to the component...  ");
+                            xhr.send(_DataStringify(component.data));
+                        }
+                    };
+
+                    if (component.cached && (!is_file)) {
+                        logger.debug("USING CACHE FOR COMPONENT: " + component.name);
+                        var cache = new ComplexStorageCache({
+                            index: component.cacheIndex,
+                            load() {
+                                _directLoad.call(this, is_file);
+                            },
+                            alternate(cacheController: TCacheController) {
+                                if (component.method === "GET") {
+                                    component.template = cacheController.cache.getCached(component.cacheIndex);
+                                    _feedComponent_.call(this, component);
+                                } else {
+                                    _directLoad.call(this, is_file);
+                                }
+                                
+                            }
+                        });
+                        (_top as any).lastCache = cache;
+                    } else {
+                        logger.debug("NOT USING CACHE FOR COMPONENT: " + component.name);
+                        _directLoad(is_file);
+                    }
+
+                }
+            } else {
+                logger.debug("CONTAINER DOESNT EXIST");
+            }
+        });
+        __promise__.then(function (standardResponse) {
+            return component.__done__().then(function () {
+                let _ret_;
+                if (typeof component.done === "function") {
+                    _ret_ = component.done.call(component, standardResponse);
+                }
+                return Promise.resolve(_ret_);
+            });
+        }, function (standardResponse) {
+            if (typeof component.fail === "function") {
+                component.fail.call(component, standardResponse)
+                .catch ((e:any)=> {throw new Error (`${e}`);});
+            }
+            return Promise.reject(new Error ("An error ocurred"));
+        }).catch(function (e:any) {
+            logger.debug("Something wrong loading the component");
+            throw new Error (`An error ocurred: ${e}`);
+        });
+        return __promise__;
+    };
+    const _componentLoaderInNode = function (component: IComponent) {
+        __promise__ = new Promise(function (resolve, reject) {
+            const _promise = __promise__;
+            const _feedComponent_ = function (component: IComponent) {
+                component.feedComponent()
+                .catch ((e:any) => {
+                    throw new Error (`An error ocurred trying to feed the component: ${component.name}. Error: ${e}`);
+                });
+                const standardResponse = {
+                    "request": null,
+                    component
+                };
+                resolve.call(_promise, standardResponse);
+            };
+            logger.debug("LOADING COMPONENT DATA {{DATA}} FROM {{URL}}".replace("{{DATA}}", _DataStringify(component.data)).replace("{{URL}}", component.url));
+
+            const _componentLoaded = function (err: any, responseText: { toString: () => any; }) {
+                if (!err) {
+                    const response = responseText.toString();
+                    logger.debug("Data received {{DATA}}".replace("{{DATA}}", _DataStringify(response)));
+                    logger.debug("CREATING COMPONENT {{NAME}}".replace("{{NAME}}", component.name));
+                    component.template = response;
+                    if (component.cached && (typeof cache !== "undefined")) {
+                        cache.save(component.name, component.template);
+                    }
+                    _feedComponent_(component);
+                } else {
+                    const standardResponse = {
+                        "request": null,
+                        component
+                    };
+                    reject.call(_promise, standardResponse);
+                }
+            };
+            if (typeof component.template === "string" && component.template !== "") {
+                // component already has a template it does not need to be reloaded
+                _feedComponent_(component);
+            } else {
+                logger.debug("Loading the component as a local file in server...");
+                const _directLoad = function () {
+                    const fs = _require_("fs");
+                    logger.debug("SENDING THE NORMAL REQUEST  ");
+                    (fs).readFile(component.url, _componentLoaded);
+                };
+
+                if (component.cached) {
+                    logger.debug("USING CACHE FOR COMPONENT: " + component.name);
+                    var cache = new ComplexStorageCache({
+                        index: component.cacheIndex,
+                        load() {
+                            _directLoad();
+                        },
+                        alternate(cacheController: TCacheController) {
+                            if (component.method === "GET") {
+                                component.template = cacheController.cache.getCached(component.cacheIndex);
+                                _feedComponent_.call(this, component);
+                            } else {
+                                _directLoad.call(this);
+                            }
+                            
+                        }
+                    });
+                    (_top as any).lastCache = cache;
+                } else {
+                    logger.debug("NOT USING CACHE FOR COMPONENT: " + component.name);
+                    _directLoad();
+                }
+
+            }
+        });
+        __promise__.then(function (standardResponse) {
+            return component.__done__().then(function () {
+                let _ret_;
+                if (typeof component.done === "function") {
+                    _ret_ = component.done.call(component, standardResponse);
+                }
+                return Promise.resolve(_ret_);
+            });
+        }, function (standardResponse) {
+            if (typeof component.fail === "function") {
+                component.fail.call(component, standardResponse)
+                .catch((e:any) => {throw new Error (`An error ocurred: ${e}`);});
+            }
+            return Promise.reject(new Error ("An error ocurred."));
+        }).catch(function (e) {
+            logger.debug(`Something wrong loading the component: ${e}`);
+        });
+        return __promise__;
+    };
+
+    let _ret_;
+    if (isBrowser) {
+        if (typeof _async !== "undefined" && _async) {
+            _ret_ = asyncLoad(_componentLoaderInBrowser, [component, _async]);
+        } else {
+            _ret_ = _componentLoaderInBrowser(component);
+        }
+    } else {
+        _ret_ = _componentLoaderInNode(component);
+    }
+    return _ret_ as Promise<any>;
+};

package/src/defaultProcessors.ts

@@ -0,0 +1,145 @@
+import { logger } from "./Logger";
+import { GlobalProcessor as Processor } from "./Processor";
+import { _top } from "./top";
+import { range } from "./range";
+import { IComponent } from "types";
+
+// Set Processors
+export const setDefaultProcessors = () => {
+    (function (_top) {
+
+        const mapper = (componentInstance:IComponent, componentName:string, valueName:string):string => {
+            /*
+             * Mapper processor
+             * @usage
+             *        $mapper(<componentName>,<valueName>)
+             *
+             * Where componentName is the name of the component (same value as in attribute tag name) without quotes
+             * and valueName is the name of the variable that contains the value to map, it can be either a property of
+             * the component instance, the data object or a global value
+             */
+    
+            if (typeof componentInstance === "undefined" || componentInstance === null) {
+                throw Error(`mapper.${componentName}.${valueName} does not have a component instance or it is null.`);
+            }
+            const globalValue = _top.global.get(valueName);
+            const componentValue = componentInstance.get(valueName);
+            const dataValue = componentInstance.data[valueName];
+            const 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:HTMLElement) {
+                    const dataItems = [...Object.keys(element)].map(k => ` data-${k}="${(typeof (element as any)[k] !== "undefined" && (element as any)[k] !== null) ? ((element as any)[k].toString()) : ("")}"`).join("");
+                    return `<quick-component name="${componentName}" ${dataItems} ></quick-component>`;
+                }).join("");
+            } else {
+                logger.debug(`${componentName}.${valueName} does not have a map property`);
+            }
+            return listItems;
+        };
+        Processor.setProcessor(mapper);
+    
+        const layout = function (componentInstance:IComponent, layoutname:string, cssfile:string):string {
+            /*
+             * Layout processor
+             * @usage
+             *        $layout(<layoutname>, <cssfile>)
+             * Where layoutname can be "portrait" or "landscape" without quotes
+             * cssfile is the uri for the css file to import
+             */
+    
+            const layout_portrait = `
+              /* CSS Document for Mobile Imports */
+              @import url("${cssfile}") (orientation:portrait);
+              @import url("${cssfile}") (max-width:460px);
+              @import url("${cssfile}") (aspect-ratio: 9/16);
+              @import url("${cssfile}") (aspect-ratio: 10/16);
+              @import url("${cssfile}") (aspect-ratio: 5/8);
+              @import url("${cssfile}") (aspect-ratio: 3/4);
+              @import url("${cssfile}") (aspect-ratio: 2/3);
+              `;
+            const layout_landscape = `
+              @import url("${cssfile}") (orientation:landscape) and (min-width:460px);
+              @import url("${cssfile}") (aspect-ratio: 16/9) and (min-width:460px);
+              @import url("${cssfile}") (aspect-ratio: 16/10) and (min-width:460px);
+              @import url("${cssfile}") (aspect-ratio: 8/5) and (min-width:460px);
+              @import url("${cssfile}") (aspect-ratio: 4/3) and (min-width:460px);
+              @import url("${cssfile}") (aspect-ratio: 3/2) and (min-width:460px);
+              `;
+            const layout_code = {
+                "landscape": layout_landscape,
+                "portrait": layout_portrait
+            };
+    
+            return (Object.hasOwn(layout_code, layoutname)) ? ((layout_code as any)[layoutname] as string) : ("");
+        };
+    
+        Processor.setProcessor(layout);
+    
+        const component = (componentInstance:IComponent ,name:string, componentClass:string, ...args:string[]):string => {
+            /*
+             * component processor
+             * @usage
+             *        $component(name=<name>, componentClass=<componentClass>, ...)
+             * Returns a component tag declaration like:
+             * <component name=<name> ...></component>
+             */
+            const arg = [...args].map(function (a) {
+                return {
+                    [a.split("=")[0]]: a.split("=")[1]
+                };
+            }).reduce(function (k1, k2) {
+                return Object.assign(k1, k2);
+            });
+            const attrs = [...Object.keys(arg)].map(function (a) {
+                return `${a}=${arg[a as any]}`;
+            }).join(" ");
+            return `<component name="${name}" componentClass="${componentClass}" ${attrs}></component>`;
+        };
+    
+        Processor.setProcessor(component);
+    
+        const quick_component = (componentInstance: IComponent,name:string, componentClass:string, ...args:string[]):string => {
+            /*
+             * component processor
+             * @usage
+             *        $quick_component(name=<name>, componentClass=<componentClass>, ...)
+             * Returns a component tag declaration like:
+             * <quick-component name=<name> ...></quick-component>
+             */
+            const arg = [...args].map(function (a) {
+                return {
+                    [a.split("=")[0]]: a.split("=")[1]
+                };
+            }).reduce(function (k1, k2) {
+                return Object.assign(k1, k2);
+            });
+            const attrs = [...Object.keys(arg)].map(function (a) {
+                return `${a}=${arg[a as any]}`;
+            }).join(" ");
+            return `<quick-component name="${name}" componentClass="${componentClass}" ${attrs}></quick-component>`;
+        };
+    
+        Processor.setProcessor(quick_component);
+    
+    
+        const repeat = (componentInstance:IComponent, length:number, text:string):string => {
+            /*
+             * Repeat processor
+             * @usage
+             *        $repeat(<length>, <text>)
+             * Where length is the number of occurrences of text
+             */
+            return range(length).map(
+                function (index) {
+                    return text.replace("{{index}}", index.toString());
+                }
+            ).join("");
+        };
+    
+        Processor.setProcessor(repeat);
+    
+    })(_top);
+    
+};
+

package/src/domain.ts

@@ -0,0 +1 @@
+export const _domain_:string = (typeof location !== "undefined" && location.hostname !== "") ? (location.hostname) : ("localhost");

package/src/findPackageNodePath.ts

@@ -0,0 +1,43 @@
+import { CONFIG } from "./CONFIG";
+import { Export } from "./Export";
+import { logger } from "./Logger";
+import { _require_, isBrowser } from "./platform";
+
+export const findPackageNodePath = function (packagename:string):string|null {
+    let sdkPath = null;
+    if (!isBrowser) {
+        const fs = _require_("fs");
+        try {
+            let sdkPaths = [
+                `${CONFIG.get("projectPath")}${CONFIG.get("relativeImportPath")}`,
+                `${CONFIG.get("basePath")}${CONFIG.get("relativeImportPath")}`,
+                `${CONFIG.get("projectPath")}`,
+                `${CONFIG.get("basePath")}`,
+                `${CONFIG.get("relativeImportPath")}`,
+                `${process.cwd()}${CONFIG.get("relativeImportPath")}`,
+                `${process.cwd()}/node_modules/` + packagename,
+                `${process.cwd()}/node_modules`,
+                `${process.cwd()}`,
+                "node_modules",
+                "./",
+                ""
+            ].concat(module.paths);
+            sdkPaths = sdkPaths.filter(p => {
+                return (fs).existsSync(p + "/" + packagename);
+            });
+            if (sdkPaths.length > 0) {
+                sdkPath = sdkPaths[0];
+                logger.info(packagename + " is Installed.");
+            } else {
+                sdkPath = "";
+                logger.info(`${packagename} is not in a standard path.`);
+            }
+        } catch (e) {
+            // do nothing
+            console.log(e);
+        }
+
+    }
+    return sdkPath;
+};
+Export(findPackageNodePath);

package/src/getType.ts

@@ -0,0 +1,36 @@
+import { __is_raw_class__ } from "./is_raw_class";
+import { ObjectName } from "./ObjectName";
+
+    /**
+     * Determine the type of the Object for any QCObjects Object
+     *
+     * @param {Object} object
+     */
+    export const __getType__ = function __getType__(o_c:any):any {
+        let _ret_ = "";
+        switch (true) {
+          case __is_raw_class__(o_c) && !!o_c.name:
+            _ret_ = o_c.name;
+            break;
+          case typeof o_c === "object" &&
+            (!!o_c.constructor &&
+              !!o_c.constructor.name)
+            && o_c.constructor.name !== "":
+            _ret_ = o_c.constructor.name;
+            break;
+          case (!!o_c && !!o_c.__classType) && o_c.__classType !== "":
+            _ret_ = o_c.__classType;
+            break;
+          case (!!o_c && !!o_c.__definition) && (!!o_c.__definition.__classType) && o_c.__definition.__classType !== "":
+            _ret_ = o_c.__definition.__classType;
+            break;
+          case typeof o_c === "function" && !!o_c.name:
+            _ret_ = o_c.name;
+            break;
+          default:
+            _ret_ = ObjectName(o_c);
+            break;
+        }
+        return _ret_;
+      };
+  

package/src/globalSettings.ts

@@ -0,0 +1,118 @@
+import { IGlobalSettings } from "types";
+import { CONFIG } from "./CONFIG";
+import { InheritClass } from "./InheritClass";
+import { logger } from "./Logger";
+import { Package } from "./Package";
+import { isBrowser } from "./platform";
+import { serviceLoader } from "./serviceLoader";
+import { _top, buildComponentsStack, configService, setConfigService } from "./top";
+import { ConfigService } from "./Service";
+
+export class GlobalSettings extends InheritClass implements IGlobalSettings{
+  static __start__() {
+    return GlobalSettings.instance.__start__();
+  }
+  [key: string]: any;
+
+  _GLOBAL:any = {};
+  private static _instance:GlobalSettings;
+  static get instance ():GlobalSettings{
+    if (typeof GlobalSettings._instance === "undefined"){
+      GlobalSettings._instance = new GlobalSettings();
+    }
+    return GlobalSettings._instance;
+  }
+
+  set(name: string, value: any) {
+    this._GLOBAL[name] = value;
+  }
+
+  get(name: string, _default?: any):any {
+    let _value:any;
+    if (typeof this._GLOBAL[name] !== "undefined") {
+      _value = this._GLOBAL[name];
+    } else if (typeof _default !== "undefined") {
+      _value = _default;
+    }
+    return _value;
+  }
+
+  __start__():Promise<any> {
+    const __load__serviceWorker = function () {
+      let _promise: Promise<ServiceWorkerRegistration> | Promise<unknown>;
+      if (isBrowser) {
+        _promise = new Promise<ServiceWorkerRegistration>(function (resolve, reject) {
+          if (("serviceWorker" in navigator) &&
+            (typeof CONFIG.get("serviceWorkerURI") !== "undefined")) {
+            CONFIG.set("serviceWorkerScope", CONFIG.get("serviceWorkerScope") ? (CONFIG.get("serviceWorkerScope")) : ("/"));
+            navigator.serviceWorker.register(CONFIG.get("serviceWorkerURI"), {
+              scope: CONFIG.get("serviceWorkerScope")
+            })
+              .then(function (registration) {
+                logger.debug("Service Worker Registered");
+                resolve.call(_promise, registration);
+              }, function (registration) {
+                logger.debug("Error registering Service Worker");
+                reject.call(_promise, registration);
+              });
+            navigator.serviceWorker.ready.then(function (registration) {
+              logger.debug("Service Worker Ready");
+              resolve.call(_promise, registration);
+            }, function (registration) {
+              logger.debug("Error loading Service Worker");
+              reject.call(_promise, registration);
+            });
+          }
+        });
+      } else {
+        _promise = Promise.resolve();
+      }
+      return _promise;
+    };
+    const _buildComponents = function () {
+      return new Promise<void>((resolve) => {
+        if (isBrowser) {
+          logger.debug("Starting to building components");
+          try {
+            buildComponentsStack();
+          } catch (e: any) {
+            throw Error(`Something went wrong trying to start components tree: ${e.message}`);
+          }
+          logger.debug("Initializing the service worker");
+          __load__serviceWorker.call(_top)
+            .catch(function (e) {
+              logger.debug(`error loading the service worker ${e}`);
+            });
+        }
+        resolve();
+      });
+    };
+
+    return new Promise<any> ((resolve) => {
+      logger.debug("Starting to load the config settings...");
+      if (CONFIG.get("useConfigService", false)) {
+        logger.debug("Loading settings using local configuration file...");
+        setConfigService(new ConfigService());
+        configService.configLoaded = _buildComponents;
+        serviceLoader(configService)
+        ?.then((standardResponse:any)=> {
+          resolve(standardResponse);
+        })
+        ?.catch ((e:any) => {throw new Error (`An error ocurred while trying to load ${configService.url}: ${e}`);});
+      } else {
+        logger.debug("Starting to load the components...");
+        _buildComponents.call(this)
+        .then(()=> {
+          resolve({});
+        })
+        .catch((e:any) => {throw new Error (`An error ocurred while trying to build the components stack. ${e}`);});
+      }
+  
+    });
+  }
+
+}
+
+Package("com.qcobjects", [
+  GlobalSettings
+]);

package/src/index.mts

@@ -1,2 +1,2 @@
-import QCObjects from "./QCObjects.js";
+import * as QCObjects from "./QCObjects.js";
 export default QCObjects;

package/src/index.ts

@@ -1,2 +1,2 @@
-import QCObjects from "./QCObjects";
+import * as QCObjects from "./QCObjects";
 export default QCObjects;