qcobjects 2.4.105-ts → 2.4.108-ts

package/build/componentLoader.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentLoader = void 0;
+const asyncLoad_1 = require("./asyncLoad");
+const ComplexStorageCache_1 = require("./ComplexStorageCache");
+const DataStringify_1 = require("./DataStringify");
+const Logger_1 = require("./Logger");
+const platform_1 = require("./platform");
+const top_1 = require("./top");
+/**
+ * Loads a simple component from a template
+ *
+ * @author: Jean Machuca <correojean@gmail.com>
+ * @param component a Component object
+ */
+const componentLoader = function (component, _async) {
+    let __promise__;
+    const _componentLoaderInBrowser = function (component) {
+        __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) {
+                    component.feedComponent();
+                    const standardResponse = {
+                        "request": xhr,
+                        component
+                    };
+                    resolve.call(_promise, standardResponse);
+                };
+                Logger_1.logger.debug("LOADING COMPONENT DATA {{DATA}} FROM {{URL}}".replace("{{DATA}}", (0, DataStringify_1._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_1.logger.debug("Data received {{DATA}}".replace("{{DATA}}", (0, DataStringify_1._DataStringify)(response)));
+                        Logger_1.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_1.logger.debug("Calling the url of component in async mode.");
+                            xhr.open(component.method, component.url, true);
+                        }
+                        catch (e) {
+                            Logger_1.logger.debug(`An error ocurred: ${e}.`);
+                            Logger_1.logger.debug("Last try has failed... The component cannot be loaded.");
+                        }
+                    }
+                    else {
+                        if ("fetch" in top_1._top) {
+                            Logger_1.logger.debug("I can use fetch...");
+                            Logger_1.logger.debug("It is a file to be loaded, so I will try to use fetch");
+                            fetch(component.url).then(response => {
+                                Logger_1.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) => { throw new Error(`An error ocurred: ${e}`); });
+                            }).catch((e) => { throw new Error(`An error ocurred: ${e}`); });
+                        }
+                    }
+                    if (!platform_1.is_phonegap && !is_file) {
+                        xhr.setRequestHeader("Content-Type", "text/html");
+                    }
+                    if (!is_file) {
+                        xhr.onload = _componentLoaded;
+                    }
+                    const _directLoad = function (is_file) {
+                        is_file = !((typeof is_file === "undefined" || !is_file));
+                        Logger_1.logger.debug("SENDING THE NORMAL REQUEST  ");
+                        if (is_file) {
+                            if (!("fetch" in top_1._top)) {
+                                Logger_1.logger.debug("I have to try to load the file using xhr...  ");
+                                xhr.send(null);
+                                if (xhr.status === XMLHttpRequest.DONE) {
+                                    _componentLoaded();
+                                }
+                            }
+                        }
+                        else {
+                            Logger_1.logger.debug("Trying to send the data to the component...  ");
+                            xhr.send((0, DataStringify_1._DataStringify)(component.data));
+                        }
+                    };
+                    if (component.cached && (!is_file)) {
+                        Logger_1.logger.debug("USING CACHE FOR COMPONENT: " + component.name);
+                        var cache = new ComplexStorageCache_1.ComplexStorageCache({
+                            index: component.cacheIndex,
+                            load() {
+                                _directLoad.call(this, is_file);
+                            },
+                            alternate(cacheController) {
+                                if (component.method === "GET") {
+                                    component.template = cacheController.cache.getCached(component.cacheIndex);
+                                    _feedComponent_.call(this, component);
+                                }
+                                else {
+                                    _directLoad.call(this, is_file);
+                                }
+                            }
+                        });
+                        top_1._top.lastCache = cache;
+                    }
+                    else {
+                        Logger_1.logger.debug("NOT USING CACHE FOR COMPONENT: " + component.name);
+                        _directLoad(is_file);
+                    }
+                }
+            }
+            else {
+                Logger_1.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) => { throw new Error(`${e}`); });
+            }
+            return Promise.reject(new Error("An error ocurred"));
+        }).catch(function (e) {
+            Logger_1.logger.debug("Something wrong loading the component");
+            throw new Error(`An error ocurred: ${e}`);
+        });
+        return __promise__;
+    };
+    const _componentLoaderInNode = function (component) {
+        __promise__ = new Promise(function (resolve, reject) {
+            const _promise = __promise__;
+            const _feedComponent_ = function (component) {
+                component.feedComponent()
+                    .catch((e) => {
+                    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_1.logger.debug("LOADING COMPONENT DATA {{DATA}} FROM {{URL}}".replace("{{DATA}}", (0, DataStringify_1._DataStringify)(component.data)).replace("{{URL}}", component.url));
+            const _componentLoaded = function (err, responseText) {
+                if (!err) {
+                    const response = responseText.toString();
+                    Logger_1.logger.debug("Data received {{DATA}}".replace("{{DATA}}", (0, DataStringify_1._DataStringify)(response)));
+                    Logger_1.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_1.logger.debug("Loading the component as a local file in server...");
+                const _directLoad = function () {
+                    const fs = (0, platform_1._require_)("fs");
+                    Logger_1.logger.debug("SENDING THE NORMAL REQUEST  ");
+                    (fs).readFile(component.url, _componentLoaded);
+                };
+                if (component.cached) {
+                    Logger_1.logger.debug("USING CACHE FOR COMPONENT: " + component.name);
+                    var cache = new ComplexStorageCache_1.ComplexStorageCache({
+                        index: component.cacheIndex,
+                        load() {
+                            _directLoad();
+                        },
+                        alternate(cacheController) {
+                            if (component.method === "GET") {
+                                component.template = cacheController.cache.getCached(component.cacheIndex);
+                                _feedComponent_.call(this, component);
+                            }
+                            else {
+                                _directLoad.call(this);
+                            }
+                        }
+                    });
+                    top_1._top.lastCache = cache;
+                }
+                else {
+                    Logger_1.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) => { throw new Error(`An error ocurred: ${e}`); });
+            }
+            return Promise.reject(new Error("An error ocurred."));
+        }).catch(function (e) {
+            Logger_1.logger.debug(`Something wrong loading the component: ${e}`);
+        });
+        return __promise__;
+    };
+    let _ret_;
+    if (platform_1.isBrowser) {
+        if (typeof _async !== "undefined" && _async) {
+            _ret_ = (0, asyncLoad_1.asyncLoad)(_componentLoaderInBrowser, [component, _async]);
+        }
+        else {
+            _ret_ = _componentLoaderInBrowser(component);
+        }
+    }
+    else {
+        _ret_ = _componentLoaderInNode(component);
+    }
+    return _ret_;
+};
+exports.componentLoader = componentLoader;

package/build/defaultProcessors.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDefaultProcessors = void 0;
+const Logger_1 = require("./Logger");
+const Processor_1 = require("./Processor");
+const top_1 = require("./top");
+const range_1 = require("./range");
+// Set Processors
+const setDefaultProcessors = () => {
+    (function (_top) {
+        const mapper = (componentInstance, componentName, valueName) => {
+            /*
+             * 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) {
+                    const 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_1.logger.debug(`${componentName}.${valueName} does not have a map property`);
+            }
+            return listItems;
+        };
+        Processor_1.GlobalProcessor.setProcessor(mapper);
+        const layout = function (componentInstance, layoutname, cssfile) {
+            /*
+             * 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[layoutname] : ("");
+        };
+        Processor_1.GlobalProcessor.setProcessor(layout);
+        const component = (componentInstance, name, componentClass, ...args) => {
+            /*
+             * 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]}`;
+            }).join(" ");
+            return `<component name="${name}" componentClass="${componentClass}" ${attrs}></component>`;
+        };
+        Processor_1.GlobalProcessor.setProcessor(component);
+        const quick_component = (componentInstance, name, componentClass, ...args) => {
+            /*
+             * 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]}`;
+            }).join(" ");
+            return `<quick-component name="${name}" componentClass="${componentClass}" ${attrs}></quick-component>`;
+        };
+        Processor_1.GlobalProcessor.setProcessor(quick_component);
+        const repeat = (componentInstance, length, text) => {
+            /*
+             * Repeat processor
+             * @usage
+             *        $repeat(<length>, <text>)
+             * Where length is the number of occurrences of text
+             */
+            return (0, range_1.range)(length).map(function (index) {
+                return text.replace("{{index}}", index.toString());
+            }).join("");
+        };
+        Processor_1.GlobalProcessor.setProcessor(repeat);
+    })(top_1._top);
+};
+exports.setDefaultProcessors = setDefaultProcessors;

package/build/domain.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._domain_ = void 0;
+exports._domain_ = (typeof location !== "undefined" && location.hostname !== "") ? (location.hostname) : ("localhost");

package/build/findPackageNodePath.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPackageNodePath = void 0;
+const CONFIG_1 = require("./CONFIG");
+const Export_1 = require("./Export");
+const Logger_1 = require("./Logger");
+const platform_1 = require("./platform");
+const findPackageNodePath = function (packagename) {
+    let sdkPath = null;
+    if (!platform_1.isBrowser) {
+        const fs = (0, platform_1._require_)("fs");
+        try {
+            let sdkPaths = [
+                `${CONFIG_1.CONFIG.get("projectPath")}${CONFIG_1.CONFIG.get("relativeImportPath")}`,
+                `${CONFIG_1.CONFIG.get("basePath")}${CONFIG_1.CONFIG.get("relativeImportPath")}`,
+                `${CONFIG_1.CONFIG.get("projectPath")}`,
+                `${CONFIG_1.CONFIG.get("basePath")}`,
+                `${CONFIG_1.CONFIG.get("relativeImportPath")}`,
+                `${process.cwd()}${CONFIG_1.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_1.logger.info(packagename + " is Installed.");
+            }
+            else {
+                sdkPath = "";
+                Logger_1.logger.info(`${packagename} is not in a standard path.`);
+            }
+        }
+        catch (e) {
+            // do nothing
+            console.log(e);
+        }
+    }
+    return sdkPath;
+};
+exports.findPackageNodePath = findPackageNodePath;
+(0, Export_1.Export)(exports.findPackageNodePath);

package/build/getType.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__getType__ = void 0;
+const is_raw_class_1 = require("./is_raw_class");
+const ObjectName_1 = require("./ObjectName");
+/**
+ * Determine the type of the Object for any QCObjects Object
+ *
+ * @param {Object} object
+ */
+const __getType__ = function __getType__(o_c) {
+    let _ret_ = "";
+    switch (true) {
+        case (0, is_raw_class_1.__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_ = (0, ObjectName_1.ObjectName)(o_c);
+            break;
+    }
+    return _ret_;
+};
+exports.__getType__ = __getType__;

package/build/globalSettings.js

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