qcobjects 2.4.105-ts → 2.4.108-ts

package/src/introspection.ts

@@ -0,0 +1,80 @@
+export const _protected_code_ = function (_:any) {
+    const __oldtoString = (typeof _.prototype !== "undefined") ? (_.prototype.toString) : (function () {
+      return "";
+    });
+    if (typeof _.prototype !== "undefined") {
+      _.prototype.toString = function ():string {
+        const _protected_symbols = [
+          "__qcobjects__",
+          "__qcobjects_sdk__",
+          "__loaded__",
+          "ComplexStorageCache",
+          "css",
+          "append",
+          "attachIn",
+          "debug",
+          "info",
+          "warn",
+          "QC_Append",
+          "set",
+          "get",
+          "done",
+          "componentDone",
+          "_new_",
+          "__new__",
+          "Class",
+          "ClassFactory",
+          "New",
+          "Export",
+          "Package",
+          "Import",
+          "subelements",
+          "componentLoader",
+          "buildComponents",
+          "Controller",
+          "View",
+          "VO",
+          "Service",
+          "serviceLoader",
+          "JSONService",
+          "ConfigService",
+          "SourceJS",
+          "SourceCSS",
+          "ArrayList",
+          "ArrayCollection",
+          "Effect",
+          "Timer",
+          "sum",
+          "avg",
+          "table",
+          "max",
+          "min",
+          "range",
+          "matrix",
+          "matrix2d",
+          "matrix3d",
+          "unique",
+          "uniqueId",
+          "shortCode",
+          "NamespaceRef"
+        ];
+        let _ret_;
+        if (_protected_symbols.includes(this.name)) {
+          _ret_ = this.name + "{ [QCObjects native code] }";
+        } else {
+          _ret_ = __oldtoString.call(this);
+        }
+        return _ret_ as string;
+      };
+    }
+  };
+  (_protected_code_)(Function);
+  export const _methods_ = function <T>(_:any):T[] {
+    const _m = [];
+    for (const i in _) {
+      if ((typeof _[i]).toLowerCase() === "function") {
+        _m.push(_[i]);
+      }
+    }
+    return _m as T[];
+  };

package/src/isQCObjects.ts

@@ -0,0 +1,19 @@
+import { InheritClass } from "./InheritClass";
+
+export const isQCObjects_Object = function (_:any):boolean {
+    return (!!((typeof _ === "object" &&
+      Object.hasOwn(_, "__classType") &&
+      (!!_.__instanceID) &&
+      Object.hasOwn(_, "__definition") &&
+      typeof _.__definition !== "undefined"
+    ))) || _ instanceof InheritClass;
+  };
+
+  export const isQCObjects_Class = function (_:any):boolean {
+    return (!!((typeof _ === "function" &&
+      (!_.__instanceID) &&
+      (!!_.__definition) &&
+      typeof _.__definition !== "undefined" &&
+      !!_.__definition.__classType
+    ))) || _.prototype instanceof InheritClass;
+  };

package/src/is_a.ts

@@ -0,0 +1,16 @@
+import { __getType__ } from "./getType";
+import { isQCObjects_Class, isQCObjects_Object } from "./isQCObjects";
+import { ObjectName } from "./ObjectName";
+
+    /**
+     * Returns if a class or object is from a determinated type
+     * @param {Object} object
+     * @param {String} typeName
+     */
+    export const is_a = function is_a(obj:any, typeName:string) {
+        return !!((typeof obj !== "undefined" && obj !== null &&
+          (((isQCObjects_Class(obj) || isQCObjects_Object(obj)) && (obj.hierarchy().includes(typeName))) ||
+            __getType__(obj) === typeName ||
+            ObjectName(obj) === typeName ||
+            typeof obj === typeName)));
+      };

package/src/is_forbidden_name.ts

@@ -0,0 +1,12 @@
+    /**
+     * Internal use to determine the forbidden names for classes
+     * Reserved words
+     *
+     * @param {String} name
+     * @param {Object} type
+     * @param {Object} definition
+     */
+    export const __is__forbidden_name__ = function (name:string) {
+        return (["__proto__", "prototype", "Object", "Map", "defineProperty", "indexOf", "toString", "__instanceID", "function", "Function"].indexOf(name) !== -1);
+      };
+  

package/src/is_raw_class.ts

@@ -0,0 +1,3 @@
+export const __is_raw_class__ = function (o_c:any) {
+    return !!((typeof o_c === "function" && o_c.toString().startsWith("class")));
+  };

package/src/loadSDK.ts

@@ -0,0 +1,59 @@
+import { CONFIG } from "./CONFIG";
+import { findPackageNodePath } from "./findPackageNodePath";
+import { Import } from "./Import";
+import { logger } from "./Logger";
+import { _require_, isBrowser, isNodeCommonJS } from "./platform";
+
+function loadSDK() {
+    if (CONFIG.get("useSDK")) {
+        (function () {
+            const remoteImportsPath = CONFIG.get("remoteImportsPath");
+            const external = (!CONFIG.get("useLocalSDK"));
+            CONFIG.set("remoteImportsPath", CONFIG.get("remoteSDKPath"));
+
+            let tryImportingSDK = false;
+            let sdkName = "QCObjects-SDK";
+            if (isBrowser) {
+                tryImportingSDK = true;
+            } else {
+                const sdkPath = findPackageNodePath("qcobjects-sdk");
+                if (sdkPath !== null) {
+                    sdkName = "qcobjects-sdk";
+                    tryImportingSDK = true;
+                } else if (sdkPath !== ""){
+                    sdkName = "node_modules/qcobjects-sdk/QCObjects-SDK";
+                    tryImportingSDK = true;
+                } else {
+                    tryImportingSDK = false;
+                }
+            }
+
+            if (tryImportingSDK) {
+                logger.info("Importing SDK... " + sdkName);
+                if (isNodeCommonJS && typeof require !== "undefined") {
+                    const sdk = _require_("qcobjects-sdk");
+                    if (sdk) {
+                        logger.debug("QCObjects SDK was loaded OK.");
+                    } else {
+                        logger.debug("QCObjects SDK could not be imported.");
+                    }
+                } else {
+                    Import(sdkName, function () {
+                        if (external) {
+                            logger.debug("QCObjects-SDK.js loaded from remote location");
+                        } else {
+                            logger.debug("QCObjects-SDK.js loaded from local");
+                        }
+                        CONFIG.set("remoteImportsPath", remoteImportsPath);
+                    }, external)
+                        ?.catch((e: any) => { throw new Error(`An error ocurred when trying to import: ${e}`); });
+                }
+            } else {
+                logger.debug("SDK has not been imported as it is not available at the moment");
+            }
+        })();
+    }
+
+}
+
+export default loadSDK;

package/src/localStorage.ts

@@ -0,0 +1,17 @@
+export var localStorage:any = window.localStorage;
+if (typeof localStorage === "undefined") {
+
+    /* Polyfill for localStorage */
+    localStorage = {
+        getItem(name:string):any {
+            return (Object.hasOwn(this, name)) ? (this[name]) : (null);
+        },
+        setItem(name:string, value:any) {
+            this[name] = value;
+        },
+        removeItem(name:string) {
+            delete this[name];
+        }
+    };
+    /* end Polyfill for localStorage */
+}

package/src/make_global.ts

@@ -0,0 +1,19 @@
+import { isBrowser } from "./platform";
+import { _top } from "./top";
+
+
+export const __make_global__ = function (f:any) {
+    if (typeof f !== "undefined") {
+        if (isBrowser) {
+            try {
+                (_top as any)[f.name] = f;
+                window[f.name] = f;
+            } catch (e:any) { throw Error (`An error ocurred: ${e}`); }
+        } else if (typeof global !== "undefined") {
+            if (!Object.hasOwn(global, f.name)) {
+                (global as any)[f.name] = f;
+            }
+        }
+    }
+
+};

package/src/mathFunctions.ts

@@ -0,0 +1,3 @@
+export const __to_number = function (value:any): number  {
+    return ((isNaN(value)) ? (new Number(0) as number) : (new Number(value) as number));
+};

package/src/platform.ts

@@ -0,0 +1,30 @@
+import { logger } from "./Logger";
+
+export const isDeno:boolean = (typeof window !== "undefined" && "Deno" in window);
+export const isBrowser:boolean = (typeof window !== "undefined" && typeof window.self !== "undefined" && window === window.self) && !isDeno;
+export const isNodeCommonJS:boolean = (typeof module !== "undefined");
+// eslint-disable-next-line no-unused-vars
+export const deno_require = (name:string):void => { /* not yet implemented */};
+export const _require_ = (name:string):any => {
+   
+  return (isDeno)?(deno_require(name)):(
+    ( (name):any => {
+      let r;
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        r = require(name);
+      } catch (e:any) {
+        logger.debug(`An error ocurred importing module. ${e}`);
+        r = {export:{}};
+      }
+      return r;
+    }  ) (name)
+  );
+};
+declare const cordova: any;
+
+export const is_phonegap:boolean = (
+  function () {
+    return (typeof cordova !== "undefined");
+  }
+)();

package/src/range.ts

@@ -0,0 +1,15 @@
+import { _protected_code_ } from "./introspection";
+
+export const range = function (start:number, stop = 0, step = 1) {
+    if (stop === 0 || typeof stop === "undefined") {
+      stop = start;
+      start = 0;
+    }
+    return Array.from({
+      length: (stop - start) / step + 1
+    }, function (_, i) {
+      return start + (i * step);
+    });
+  };
+  (_protected_code_)(range);
+

package/src/routings.ts

@@ -0,0 +1,18 @@
+import {  TComponentRouting } from "types";
+
+export const __routing_params__ = function (routing:TComponentRouting, routingPath:string):object {
+    const standardRoutingPath = routing.path.replace(/{(.*?)}/g, "(?<$1>.*)"); // allowing {param}
+    return {
+        ...[...routingPath.matchAll((new RegExp(standardRoutingPath, "g")))][0].groups
+    };
+};
+
+export const __valid_routings__ = function (routings:TComponentRouting[], routingPath:string):TComponentRouting[] {
+    return routings.filter(function (routing) {
+        const standardRoutingPath = routing.path.replace(/{(.*?)}/g, "(?<$1>.*)");
+        return (new RegExp(standardRoutingPath, "g")).test(routingPath);
+    }).reverse();
+};
+export const __valid_routing_way__ = function (validRoutingWays:string[], routingWay:string) {
+    return validRoutingWays.includes(routingWay);
+};

package/src/secretKey.ts

@@ -0,0 +1,3 @@
+import { isBrowser } from "./platform";
+
+export const _secretKey = (isBrowser)?(location.host):("secret");

package/src/serviceLoader.ts

@@ -0,0 +1,306 @@
+import { IService, TCacheController } from "types";
+import { asyncLoad } from "./asyncLoad";
+import { ComplexStorageCache } from "./ComplexStorageCache";
+import { _DataStringify } from "./DataStringify";
+import { logger } from "./Logger";
+import { _require_, isBrowser } from "./platform";
+import { _top } from "./top";
+
+/**
+ * Loads a simple component from a template
+ *
+ * @author: Jean Machuca <correojean@gmail.com>
+ * @param service a Service object
+ */
+export const serviceLoader = function (service:IService, _async = false):Promise<unknown>|undefined {
+    const _serviceLoaderInBrowser = function (service:IService):Promise<unknown> {
+        var _promise = new Promise(
+            function (resolve, reject) {
+
+                logger.debug("LOADING SERVICE DATA {{DATA}} FROM {{URL}}".replace("{{DATA}}", _DataStringify(service.data)).replace("{{URL}}", service.url));
+                const xhr = new XMLHttpRequest();
+                xhr.withCredentials = service.withCredentials;
+                const xhrasync = true; // always async because xhr sync is deprecated
+                xhr.open(service.method, service.url, xhrasync);
+                for (const header in service.headers) {
+                    try {
+                        if (typeof service.headers[header] !== "function") {
+                            xhr.setRequestHeader(header, service.headers[header]);
+                        }
+                    } catch (e:any) {
+                        logger.debug("Something went wrong when assign the header " + header);
+                        logger.debug(`An error ocurred: ${e}`);
+                    }
+                }
+                xhr.onload = function () {
+                    if (xhr.status === 200) {
+                        const response = xhr.responseText;
+                        logger.debug("Data received {{DATA}}".replace("{{DATA}}", _DataStringify(response)));
+                        logger.debug("CREATING SERVICE {{NAME}}".replace("{{NAME}}", service.name));
+                        service.template = response;
+                        if (service.cached && (typeof cache !== "undefined")) {
+                            cache.save(service.name, service.template);
+                        }
+                        if (typeof service.done === "function") {
+                            var standardResponse = {
+                                "request": xhr,
+                                service
+                            };
+                            service.done.call(service, standardResponse);
+                            resolve.call(_promise, standardResponse);
+                        }
+                    } else {
+                        if (typeof service.fail === "function") {
+                            var standardResponse = {
+                                "request": xhr,
+                                service
+                            };
+                            service.fail.call(service, standardResponse);
+                            reject.call(_promise, standardResponse);
+                        }
+                    }
+                };
+
+                const _directLoad = function () {
+                    logger.debug("SENDING THE NORMAL REQUEST  ");
+                    try {
+                        xhr.send(_DataStringify(service.data));
+                    } catch (e:any) {
+                        logger.debug("SOMETHING WRONG WITH REQUEST  ");
+                        logger.debug(`An error ocurred: ${e}`);
+                        reject.call(_promise, {
+                            request: xhr,
+                            service
+                        });
+                    }
+                };
+
+                if (service.cached) {
+                    var cache = new ComplexStorageCache({
+                        index: service.data,
+                        load() {
+                            _directLoad.call(this);
+                        },
+                        alternate(cacheController:TCacheController) {
+                            if (service.method === "GET") {
+                                service.template = cacheController.cache.getCached(service.name);
+                                if (typeof service.done === "function") {
+                                    const standardResponse = {
+                                        "request": xhr,
+                                        service
+                                    };
+                                    service.done.call(service, standardResponse);
+                                    resolve.call(_promise, standardResponse);
+                                }
+                            } else {
+                                _directLoad();
+                            }
+                            
+                        }
+                    });
+                    (_top as any).lastCache = cache;
+                } else {
+                    _directLoad();
+                }
+
+                return xhr;
+            }
+        );
+        return _promise;
+    };
+
+    const _serviceLoaderInNode = function (service:IService) {
+        var _promise = new Promise(
+            function (resolve, reject) {
+                if (typeof URL === "undefined") {
+                    global.URL = (_require_("url")).URL;
+                    // eslint-disable-next-line no-unused-vars
+                    const URL = global.URL;
+                }
+                const serviceURL = new URL(service.url);
+                var req;
+                service.useHTTP2 = Object.hasOwn(service, "useHTTP2") && service.useHTTP2;
+
+
+                const captureEvents = function (req:any) {
+                    logger.debug("LOADING SERVICE DATA (non-browser) {{DATA}} FROM {{URL}}".replace("{{DATA}}", _DataStringify(service.data)).replace("{{URL}}", service.url));
+                    let dataXML:any;
+                    const standardResponse = {
+                        "http2Client": client,
+                        "request": req,
+                        service,
+                        "responseHeaders": null
+                    };
+
+                    if (typeof service.data === "object" && service.data !== null) {
+                        if (service.useHTTP2) {
+                            try {
+                                logger.debug("Sending data...");
+                                const buffer = new Buffer(_DataStringify(service.data));
+                                req.write(buffer);
+                            } catch (e:any) {
+                                logger.debug("It was not possible to send any data");
+                                logger.debug(`An error ocurred: ${e}`);
+                            }
+                        }
+                    }
+
+                    dataXML = "";
+                    req.on("response", (responseHeaders:any) => {
+                        logger.debug("receiving response...");
+                        standardResponse.responseHeaders = responseHeaders;
+                        /*
+                        for (const name in responseHeaders) {
+                          logger.debug(`${name}: ${responseHeaders[name]}`);
+                        }
+                        */
+                        dataXML = "";
+                    });
+                    req.on("data", (chunk:any) => {
+                        logger.debug("receiving data...");
+                        // do something with the data
+                        dataXML += "" + chunk.toString();
+                        service.template = dataXML;
+                    });
+                    if (service.useHTTP2) {
+                        req.resume();
+                    }
+                    req.on("end", () => {
+                        logger.debug("ending call...");
+                        service.template = dataXML;
+                        if (Object.hasOwn(service, "useHTTP2") && service.useHTTP2) {
+                            client.destroy();
+                        } else {
+                            req.destroy();
+                        }
+                        service.done.call(service, standardResponse);
+                        resolve.call(_promise, standardResponse);
+                    });
+                    if (service.useHTTP2) {
+                        req.end();
+                    }
+
+                };
+
+                try {
+                    let requestOptions;
+                    if (service.useHTTP2) {
+                        logger.debug("using http2");
+                        const http2 = _require_("http2");
+                        var client = (http2).connect(serviceURL.origin);
+                        requestOptions = Object.assign({
+                            ":method": service.method,
+                            ":path": serviceURL.pathname
+                        }, service.options);
+                        requestOptions = Object.assign(requestOptions, service.headers);
+                        req = client.request(requestOptions);
+                        req.setEncoding("utf8");
+                        captureEvents(req);
+                    } else {
+                        if (serviceURL.protocol === "http:") {
+                            const http = _require_("http");
+                            const request = (http).request;
+                            requestOptions = Object.assign({
+                                "url": service.url,
+                                headers: service.headers
+                            }, service.options);
+                            req = request(service.url);
+                            captureEvents(req);
+                        } else if (serviceURL.protocol === "https:") {
+                            const https = _require_("https");
+                            requestOptions = Object.assign({
+                                hostname: serviceURL.hostname,
+                                port: serviceURL.port,
+                                path: serviceURL.pathname,
+                                method: service.method,
+                                headers: service.headers
+                            }, service.options);
+                            const _req_ = (https).request(requestOptions, function (req:any) {
+                                captureEvents(req);
+                            });
+                            _req_.end();
+                        } else {
+                            const e = "Protocol not supported: " + serviceURL.protocol;
+                            logger.debug(e);
+                            throw new Error(e);
+                        }
+                    }
+
+
+                } catch (e:any) {
+                    logger.debug(e);
+                    service.fail.call(service, e);
+                    reject.call(_promise, e);
+
+                }
+            }).catch( (e:any) => {
+                logger.debug(`Something happened when trying to call the service: ${service.name}. Error: ${e}`);
+                service.fail.call(service, e);
+            });
+        return _promise;
+
+    };
+
+    const _serviceLoaderMockup = function (service:IService) {
+        var _promise = new Promise(
+            function (resolve) {
+                logger.debug(`Calling mockup service ${service.name} ...`);
+                const standardResponse = {
+                    "request": null,
+                    service,
+                    "responseHeaders": service.responseHeaders
+                };
+                if (typeof service.mockup === "function") {
+                    service.mockup.call(service, standardResponse);
+                } else {
+                    service.done.call(service, standardResponse);
+                }
+                resolve.call(_promise, standardResponse);
+            });
+        return _promise;
+    };
+    const _serviceLoaderLocal = function (service:IService) {
+        var _promise = new Promise(
+            function (resolve) {
+                logger.debug(`Calling local service ${service.name} ...`);
+                const standardResponse = {
+                    "request": null,
+                    service,
+                    "responseHeaders": service.responseHeaders
+                };
+                if (typeof service.local === "function") {
+                    service.local.call(service, standardResponse);
+                } else {
+                    service.done.call(service, standardResponse);
+                }
+                resolve.call(_promise, standardResponse);
+            });
+        return _promise;
+    };
+
+    let _ret_: Promise<unknown>;
+    switch (service.kind) {
+        case "rest":
+            if (isBrowser) {
+                if (typeof _async !== "undefined" && _async) {
+                    _ret_ = asyncLoad(_serviceLoaderInBrowser, [service, _async]);
+                } else {
+                    _ret_ = _serviceLoaderInBrowser(service);
+                }
+            } else {
+                _ret_ = _serviceLoaderInNode(service);
+            }
+            break;
+        case "mockup":
+            _ret_ = _serviceLoaderMockup(service);
+            break;
+        case "local":
+            _ret_ = _serviceLoaderLocal(service);
+            break;
+        default:
+            logger.debug(`The value of the kind property of the service ${service.name} is not valid`);
+            _ret_ = Promise.resolve();
+            break;
+    }
+    return _ret_;
+};

package/src/shortCode.ts

@@ -0,0 +1,11 @@
+import { _Crypt } from "./Crypt";
+
+export const shortCode = function () {
+    const length = 1000;
+    const code1 = _Crypt.encrypt((Math.random() * length).toString().replace(".", ""), (new Date()).getTime().toString());
+    const code2 = _Crypt.encrypt((Math.random() * length).toString().replace(".", ""), (new Date((new Date()).getTime() - 1000 * 1000)).getTime().toString());
+    const shortCode = [...code2].map((o1:any, index:any):any => {
+      return [...code1][index] === o1 ? null : o1;
+    }).filter((c:any) => c !== null).join("");
+    return shortCode;
+  };

package/src/subelements.ts

@@ -0,0 +1,4 @@
+export const subelements = function subelements<T>(this: any, query: string): T[] {
+  const _self = this;
+  return [..._self.querySelectorAll(query)] as T[];
+};

package/src/super.ts

@@ -0,0 +1,17 @@
+import { ClassFactory } from "./ClassFactory";
+
+/**
+ * Returns a method from a superior QCObjects Class
+ * It is useful for Class Inheritance in the _new_ and __new__ method constructors
+ * @example _super_('MySuperClass','MySuperMethod').call(this,params) #where this is the current instance and params are method parameters
+ *
+ * @param {String} className
+ * @param {String} classMethodName
+ * @param {Object} params
+ */
+export const _super_ = function <T>(className: string, classMethodName: string):T {
+  return (ClassFactory(className))[classMethodName] as T;
+};
+_super_.prototype.toString = function () {
+  return "_super_(className,classMethodName,params) { [QCObjects native code] }";
+};

package/src/tag_filter.ts

@@ -0,0 +1 @@
+export const _tag_filter_ = "quick-component:not([loaded]),component:not([loaded])";