qcobjects 2.4.107-ts → 2.4.108-ts

package/build/ComponentFactory.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponents = exports._buildComponentsFromElements_ = exports._buildComponentFromElement_ = exports.ComponentURI = void 0;
+const Class_1 = require("./Class");
+const ClassFactory_1 = require("./ClassFactory");
+const Component_1 = require("./Component");
+const CONFIG_1 = require("./CONFIG");
+const DOMCreateElement_1 = require("./DOMCreateElement");
+const getType_1 = require("./getType");
+const Logger_1 = require("./Logger");
+const New_1 = require("./New");
+const Package_1 = require("./Package");
+const platform_1 = require("./platform");
+const tag_filter_1 = require("./tag_filter");
+/**
+ * Returns a standarized uri for a component
+ * @example
+ * templateURI = ComponentURI({'COMPONENTS_BASE_PATH':'','COMPONENT_NAME':'','TPLEXTENSION':'','TPL_SOURCE':''})
+ * @author: Jean Machuca <correojean@gmail.com>
+ * @param params an object with the params to build the uri path
+ */
+const ComponentURI = ({ TPL_SOURCE, COMPONENTS_BASE_PATH, COMPONENT_NAME, TPLEXTENSION }) => {
+    const templateURI = (TPL_SOURCE === "default") ? (`${COMPONENTS_BASE_PATH}${COMPONENT_NAME}.${TPLEXTENSION}`) : ("");
+    return templateURI;
+};
+exports.ComponentURI = ComponentURI;
+const _buildComponentFromElement_ = function (element, __parent__) {
+    const __shadowed_not_set = (element.getAttribute("shadowed") === null);
+    const __tplsource_attr_not_set = (element.getAttribute("template-source") === null);
+    const shadowed = (element.getAttribute("shadowed") === "true");
+    const __cached_not_set = (element.getAttribute("cached") === null);
+    const cached = (element.getAttribute("cached") === "true");
+    let tplextension = (typeof CONFIG_1.CONFIG.get("tplextension") !== "undefined") ? (CONFIG_1.CONFIG.get("tplextension")) : ("html");
+    tplextension = (element.getAttribute("tplextension") !== null) ? (element.getAttribute("tplextension")) : (tplextension);
+    let _componentName = element.getAttribute("name");
+    const _componentClassName = (element.getAttribute("componentClass") !== null) ? (element.getAttribute("componentClass")) : ("Component");
+    const __componentClassName = (CONFIG_1.CONFIG.get("preserveComponentBodyTag")) ? ((_componentName !== null) ? ("com.qcobjects.components." + _componentName + ".ComponentBody") : ("com.qcobjects.components.ComponentBody")) : (_componentClassName);
+    _componentName = (_componentName !== null) ? (_componentName) : (((0, ClassFactory_1.ClassFactory)(__componentClassName) &&
+        typeof (0, ClassFactory_1.ClassFactory)(__componentClassName).name !== "undefined") ? ((0, ClassFactory_1.ClassFactory)(__componentClassName).name) : (""));
+    const __classDefinition = (0, ClassFactory_1.ClassFactory)(__componentClassName);
+    const __tplsource_prop_set = !!((__componentClassName !== "Component" && ((typeof __classDefinition !== "undefined" && typeof __classDefinition.tplsource === "string") && __classDefinition.tplsource !== "")));
+    const tplsource = (__tplsource_attr_not_set && __tplsource_prop_set) ? (__classDefinition.tplsource) : ((__tplsource_attr_not_set) ? ("default") : (element.getAttribute("template-source")));
+    Logger_1.logger.debug(`template source for  ${_componentName} is ${tplsource} `);
+    Logger_1.logger.debug(`type for ${_componentName} is ${(0, getType_1.__getType__)(__classDefinition)} `);
+    const componentURI = (0, exports.ComponentURI)({
+        "COMPONENTS_BASE_PATH": CONFIG_1.CONFIG.get("componentsBasePath"),
+        "COMPONENT_NAME": _componentName,
+        "TPLEXTENSION": tplextension,
+        "TPL_SOURCE": tplsource
+    });
+    if (CONFIG_1.CONFIG.get("preserveComponentBodyTag")) {
+        (0, Package_1.Package)((_componentName !== "") ? ("com.qcobjects.components." + _componentName + "") : ("com.qcobjects.components"), [
+            (0, Class_1.Class)("ComponentBody", Component_1.Component, {
+                name: _componentName,
+                tplsource,
+                tplextension,
+                reload: true
+            })
+        ]);
+    }
+    const __create_component_instance_ = function () {
+        const __shadowed = (__shadowed_not_set) ? ((__classDefinition && __classDefinition.shadowed) || Component_1.Component.shadowed) : (shadowed);
+        const __definition = {
+            __parent__,
+            name: _componentName,
+            cached: (__cached_not_set) ? (Component_1.Component.cached) : (cached),
+            shadowed: __shadowed,
+            tplextension,
+            body: (CONFIG_1.CONFIG.get("preserveComponentBodyTag")) ? ((0, DOMCreateElement_1._DOMCreateElement)("componentBody")) : (element),
+            templateURI: componentURI,
+            tplsource
+        };
+        if (typeof _componentName === "undefined" || _componentName === "" || _componentName === null) {
+            /* this allows to use the original property defined
+            in the component definition if it is not present in the tag */
+            delete __definition.name;
+        }
+        if (componentURI === "") {
+            /* this allows to use the original property defined
+            in the component definition if it is not present in the tag */
+            delete __definition.templateURI;
+        }
+        const newComponent = (0, New_1.New)(__classDefinition, __definition);
+        if (CONFIG_1.CONFIG.get("preserveComponentBodyTag")) {
+            if (typeof newComponent !== "undefined") {
+                element.append(newComponent.body);
+            }
+        }
+        return newComponent;
+    };
+    const newComponent = __create_component_instance_();
+    return newComponent;
+};
+exports._buildComponentFromElement_ = _buildComponentFromElement_;
+const _buildComponentsFromElements_ = function (elements, __parent__) {
+    let componentsBuiltWith = [];
+    if (platform_1.isBrowser) {
+        componentsBuiltWith = elements.map(function (element) {
+            return (0, exports._buildComponentFromElement_)(element, __parent__);
+        });
+    }
+    else {
+        Logger_1.logger.debug("[_buildComponentsFromElements_] not implemented for Non-Browser environments");
+    }
+    return componentsBuiltWith;
+};
+exports._buildComponentsFromElements_ = _buildComponentsFromElements_;
+const buildComponents = (element) => {
+    const tagFilter = tag_filter_1._tag_filter_;
+    const elements = element.subelements(tagFilter);
+    return (0, exports._buildComponentsFromElements_)(elements, null);
+};
+exports.buildComponents = buildComponents;

package/build/ConfigSettings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigSettings = void 0;
+const basePath_1 = require("./basePath");
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+class ConfigSettings extends InheritClass_1.InheritClass {
+    _CONFIG = {
+        "relativeImportPath": "",
+        "remoteImportsPath": "",
+        "remoteSDKPath": "https://sdk.qcobjects.dev/",
+        "asynchronousImportsLoad": false,
+        "removePackageScriptAfterLoading": true,
+        "componentsBasePath": "",
+        "delayForReady": 0,
+        "preserveComponentBodyTag": false,
+        "useConfigService": false,
+        "routingWay": "hash",
+        "useSDK": true,
+        "useLocalSDK": false,
+        "basePath": basePath_1._basePath_
+    };
+    static _instance;
+    _CONFIG_ENC = "";
+    set(name, value) {
+        this._CONFIG[name] = value;
+    }
+    get(name, _defaultValue) {
+        return this._CONFIG[name] || _defaultValue;
+    }
+    static get instance() {
+        if (typeof ConfigSettings._instance === "undefined") {
+            ConfigSettings._instance = new ConfigSettings();
+        }
+        return ConfigSettings._instance;
+    }
+}
+exports.ConfigSettings = ConfigSettings;
+(0, Package_1.Package)("com.qcobjects", [ConfigSettings]);

package/build/Controller.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const ClassFactory_1 = require("./ClassFactory");
+const getType_1 = require("./getType");
+const InheritClass_1 = require("./InheritClass");
+const Logger_1 = require("./Logger");
+const New_1 = require("./New");
+const Package_1 = require("./Package");
+const platform_1 = require("./platform");
+class Controller extends InheritClass_1.InheritClass {
+    component;
+    dependencies = [];
+    constructor({ component, dependencies }) {
+        super({ component, dependencies });
+        this.component = component;
+        this.dependencies = dependencies;
+        if (typeof this.component === "undefined" || this.component === null) {
+            throw Error(`${(0, getType_1.__getType__)(this)} must be called with a component`);
+        }
+    }
+    // eslint-disable-next-line no-unused-vars
+    fail(...args) {
+        throw new Error("Method not implemented.");
+    }
+    routingSelectedAttr(attrName) {
+        return this.component?.routingSelected.map((r) => {
+            return r[attrName];
+        }).filter(function (v) {
+            return v;
+        }).pop();
+    }
+    isTouchable() {
+        return ("ontouchstart" in window) ||
+            (navigator.MaxTouchPoints > 0) ||
+            (navigator.msMaxTouchPoints > 0);
+    }
+    onpress(subelementSelector, handler) {
+        if (platform_1.isBrowser) {
+            try {
+                if (this.isTouchable()) {
+                    (this.component?.componentRoot?.subelements(subelementSelector))[0].addEventListener("touchstart", handler, {
+                        passive: true
+                    });
+                }
+                else {
+                    (this.component?.componentRoot?.subelements(subelementSelector))[0].addEventListener("click", handler, {
+                        passive: true
+                    });
+                }
+            }
+            catch (e) {
+                Logger_1.logger.debug(`An error ocurred: ${e}.`);
+                Logger_1.logger.debug("No button to assign press event");
+            }
+        }
+    }
+    createRoutingController() {
+        const controller = this;
+        const component = controller.component;
+        const controllerName = controller.routingSelectedAttr("controllerclass");
+        if (typeof controllerName !== "undefined") {
+            const _Controller = (0, ClassFactory_1.ClassFactory)(controllerName);
+            if (typeof _Controller !== "undefined" && component !== null) {
+                component.routingController = (0, New_1.New)(_Controller, {
+                    component
+                }); // Initializes the main controller for the component
+                if (typeof component.routingController !== "undefined"
+                    && Object.hasOwn(component.routingController, "done")
+                    && typeof component.routingController.done === "function") {
+                    component.routingController.done.call(component.routingController);
+                }
+            }
+        }
+    }
+    done() { }
+}
+exports.Controller = Controller;
+(0, Package_1.Package)("com.qcobjects.controllers", [
+    Controller
+]);

package/build/Crypt.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._DecryptObject = exports._CryptObject = exports._Crypt = void 0;
+const Base64_1 = require("./Base64");
+const DataStringify_1 = require("./DataStringify");
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+const secretKey_1 = require("./secretKey");
+class _Crypt extends InheritClass_1.InheritClass {
+    string = "";
+    key = "";
+    // eslint-disable-next-line no-unused-vars
+    encrypt(_string_, key) {
+        throw new Error("Method not implemented.");
+    }
+    // eslint-disable-next-line no-unused-vars
+    decrypt(_string_, key) {
+        throw new Error("Method not implemented.");
+    }
+    last_string = "";
+    last_key = "";
+    construct = false;
+    _new_(o) {
+        const string = o.string;
+        let key = (Object.hasOwn(o, "key")) ? (o.key) : ("");
+        this.__new__(o);
+        key = (key === "") ? (this.__instanceID.toString()) : (key);
+        this.last_key = key;
+        this.last_string = string;
+        this.construct = true;
+    }
+    _encrypt() {
+        const string = this.string;
+        const key = this.key;
+        let result = "";
+        let char;
+        let keychar;
+        for (let i = 0; i < string.length; i++) {
+            char = string.substr(i, 1);
+            keychar = key.substr((i % key.length) - 1, 1);
+            char = String.fromCharCode(char.charCodeAt(0) + keychar.charCodeAt(0));
+            result += char;
+        }
+        this.last_string = Base64_1.Base64.encode(result);
+        return this.last_string;
+    }
+    _decrypt() {
+        let string = this.string;
+        const key = this.key;
+        let result = "";
+        let char;
+        let keychar;
+        string = Base64_1.Base64.decode(string);
+        for (let i = 0; i < string.length; i++) {
+            char = string.substr(i, 1);
+            keychar = key.substr((i % key.length) - 1, 1);
+            char = String.fromCharCode(char.charCodeAt(0) - keychar.charCodeAt(0));
+            result += char;
+        }
+        this.last_string = result;
+        return this.last_string;
+    }
+    static encrypt(string, key) {
+        const crypt = new _Crypt({
+            string,
+            key: (key !== "") ? (key) : ("12345678ABC")
+        });
+        return crypt._encrypt();
+    }
+    static decrypt(string, key) {
+        const crypt = new _Crypt({
+            string,
+            key: (key !== "") ? (key) : ("12345678ABC")
+        });
+        return crypt._decrypt();
+    }
+}
+exports._Crypt = _Crypt;
+const _CryptObject = function (o) {
+    return _Crypt.encrypt((0, DataStringify_1._DataStringify)(o), secretKey_1._secretKey);
+};
+exports._CryptObject = _CryptObject;
+const _DecryptObject = function (s) {
+    return (s === "") ? ({}) : (JSON.parse(_Crypt.decrypt(s, secretKey_1._secretKey)));
+};
+exports._DecryptObject = _DecryptObject;
+(0, Package_1.Package)("com.qcobjects", [_Crypt]);

package/build/DDO.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DDO = void 0;
+const Export_1 = require("./Export");
+const InheritClass_1 = require("./InheritClass");
+const Logger_1 = require("./Logger");
+const ObjectName_1 = require("./ObjectName");
+/**
+ * Dynamic Data Objects Class
+ * Usage:
+ * Class('TestDDO',{
+ *    data: {},
+ *    _new_ (){
+ *        this.ddo = New(DDO,{
+ *            instance:this,
+ *            name:'data',
+ *            value:{},
+ *            fget (value){
+ *                logger.debug('returned value '+ value );
+ *            }
+ *            })
+ *    }
+ * });
+ *
+ */
+class DDO extends InheritClass_1.InheritClass {
+    constructor({ instance, name, fget, fset, value }) {
+        super({
+            instance,
+            name,
+            fget,
+            fset,
+            value
+        });
+        this._new_({
+            instance,
+            name,
+            fget,
+            fset,
+            value
+        });
+    }
+    _new_({ instance, name, fget, fset }) {
+        const ddoInstance = this;
+        var name = (typeof name === "undefined") ? ((0, ObjectName_1.ObjectName)(ddoInstance)) : (name);
+        Object.defineProperty(instance, name, {
+            set(val) {
+                const _value = val;
+                Logger_1.logger.debug("value changed " + name);
+                let ret;
+                if (typeof fset !== "undefined" && typeof fset === "function") {
+                    ret = fset(_value);
+                }
+                else {
+                    ret = _value;
+                }
+                instance["_" + name] = ret;
+            },
+            get() {
+                const _value = instance["_" + name];
+                Logger_1.logger.debug("returning value " + name);
+                const is_ddo = (v) => {
+                    if (typeof v === "object" && Object.hasOwn(v, "value")) {
+                        return v.value;
+                    }
+                    return v;
+                };
+                let ret;
+                if (typeof fget !== "undefined" && typeof fget === "function") {
+                    ret = fget(is_ddo(_value));
+                }
+                else {
+                    ret = is_ddo(_value);
+                }
+                return ret;
+            }
+        });
+    }
+}
+exports.DDO = DDO;
+(0, Export_1.Export)(DDO);

package/build/DOMCreateElement.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._DOMCreateElement = void 0;
+const platform_1 = require("./platform");
+const _DOMCreateElement = function (elementName) {
+    let _ret_;
+    if (platform_1.isBrowser) {
+        _ret_ = document.createElement(elementName);
+    }
+    else {
+        _ret_ = {};
+    }
+    return _ret_;
+};
+exports._DOMCreateElement = _DOMCreateElement;

package/build/DataStringify.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._DataStringify = void 0;
+const LegacyCopy_1 = require("./LegacyCopy");
+const _DataStringify = function (data) {
+    const getCircularReplacer = function () {
+        const seen = new WeakSet();
+        let _level = 0;
+        return function (key, value) {
+            if (typeof value === "object" && value !== null) {
+                if (seen.has(value)) {
+                    _level += 1;
+                    return (_level <= 3) ? ((0, LegacyCopy_1._LegacyCopy)(value)) : (null);
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    };
+    return JSON.stringify(data, getCircularReplacer());
+};
+exports._DataStringify = _DataStringify;

package/build/DefaultTemplateHandler.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTemplateHandler = void 0;
+const Logger_1 = require("./Logger");
+const Processor_1 = require("./Processor");
+const RegisterClass_1 = require("./RegisterClass");
+class DefaultTemplateHandler {
+    template = "";
+    __definition = {};
+    static __definition = {};
+    component;
+    constructor({ component, template }) {
+        this.component = component;
+        this.template = template;
+    }
+    assign(data) {
+        const templateInstance = this;
+        if (typeof templateInstance.component === "undefined") {
+            throw new Error("DefaultTemplateHandler.assign: component is undefined");
+        }
+        if (typeof templateInstance.component.processorHandler === "undefined") {
+            throw new Error("DefaultTemplateHandler.assign: component.processorHandler is undefined");
+        }
+        const processorHandler = templateInstance.component.processorHandler;
+        processorHandler.component = templateInstance.component;
+        let parsedAssignmentText = (typeof templateInstance.template !== "undefined") ? (templateInstance.template) : ("");
+        if (typeof data === "object") {
+            [...Object.keys(data)].map((k) => {
+                let _value = data[k];
+                if (typeof _value === "string" || typeof _value === "number" || (!isNaN(_value))) {
+                    try {
+                        _value = Processor_1.GlobalProcessor.processObject.bind(processorHandler).call(processorHandler, _value, templateInstance.component);
+                        parsedAssignmentText = parsedAssignmentText.replace((new RegExp(`{{${k}}}`, "g")), _value);
+                    }
+                    catch (e) {
+                        Logger_1.logger.warn(`${templateInstance.component.name} could not parse processors.`);
+                        throw Error(`${templateInstance.component.name} could not parse processors. Reason: ${e.message}`);
+                    }
+                }
+                return k;
+            });
+        }
+        else {
+            Logger_1.logger.debug(`${templateInstance.component.name}.data is not an object`);
+        }
+        try {
+            parsedAssignmentText = Processor_1.GlobalProcessor.processObject.call(processorHandler, parsedAssignmentText, templateInstance.component);
+        }
+        catch (e) {
+            Logger_1.logger.warn(`${templateInstance.component.name} could not parse processors.`);
+            throw Error(`${templateInstance.component.name} could not parse processors. Reason: ${e.message}`);
+        }
+        return parsedAssignmentText;
+    }
+}
+exports.DefaultTemplateHandler = DefaultTemplateHandler;
+(0, RegisterClass_1.RegisterClass)(DefaultTemplateHandler, "com.qcobjects");

package/build/DocumentLayout.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentLayout = void 0;
+const getDocumentLayout = function () {
+    const h = (w, h) => {
+        return w > h ? "landscape" : null;
+    };
+    const v = (w, h) => {
+        return h > w ? "portrait" : null;
+    };
+    const square = (w, h) => {
+        return w === h ? "square" : null;
+    };
+    return [
+        h(document.documentElement.clientWidth, document.documentElement.clientHeight),
+        v(document.documentElement.clientWidth, document.documentElement.clientHeight),
+        square(document.documentElement.clientWidth, document.documentElement.clientHeight)
+    ].filter(e => e !== null).pop();
+};
+exports.getDocumentLayout = getDocumentLayout;

package/build/Effect.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Effect = void 0;
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+class Effect extends InheritClass_1.InheritClass {
+    // eslint-disable-next-line no-unused-vars
+    done(...args) {
+        throw new Error("Method not implemented.");
+    }
+    ;
+    // eslint-disable-next-line no-unused-vars
+    apply(...args) {
+        throw new Error("Method not implemented.");
+    }
+    duration = 1000;
+    animate({ timing, draw, duration }) {
+        const _self = this;
+        const start = performance.now();
+        requestAnimationFrame(function animate(time) {
+            // timeFraction goes from 0 to 1
+            let timeFraction = (time - start) / duration;
+            if (timeFraction > 1)
+                timeFraction = 1;
+            // calculate the current animation state
+            const progress = timing(timeFraction);
+            draw(Math.round(progress * 100)); // draw it
+            if (timeFraction < 1) {
+                requestAnimationFrame(animate);
+            }
+            else {
+                // if this is an object with a done method
+                if (typeof _self !== "undefined" &&
+                    _self !== null &&
+                    Object.hasOwn(_self, "done") &&
+                    (typeof _self.done).toLowerCase() === "function") {
+                    _self.done.call(_self);
+                }
+            }
+        });
+    }
+}
+exports.Effect = Effect;
+(0, Package_1.Package)("com.qcobjects.effects.base", [
+    Effect
+]);

package/build/Export.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Export = void 0;
+const make_global_1 = require("./make_global");
+const Export = function (f) {
+    return (0, make_global_1.__make_global__)(f);
+};
+exports.Export = Export;
+exports.Export.prototype.toString = function () {
+    return "Export(function or symbol) { [QCObjects native code] }";
+};