qcobjects 2.4.107-ts → 2.4.108-ts

package/build/Ready.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Ready = exports.ready = exports.Ready = void 0;
+const CONFIG_1 = require("./CONFIG");
+const platform_1 = require("./platform");
+const PrimaryCollections_1 = require("./PrimaryCollections");
+const top_1 = require("./top");
+/**
+ * Defines a Custom Ready listener
+ */
+const Ready = function Ready(e) {
+    if (platform_1.isBrowser) {
+        PrimaryCollections_1._QC_READY_LISTENERS.push(e.bind(window));
+    }
+    else if (typeof global !== "undefined") {
+        PrimaryCollections_1._QC_READY_LISTENERS.push(e.bind(global));
+    }
+};
+exports.Ready = Ready;
+exports.ready = exports.Ready; // case insensitive ready option
+/**
+ * Default Ready event function for window. Executes all micro ready events of Import calls
+ *
+ * @param {Object} e
+ */
+// eslint-disable-next-line no-unused-vars
+const _Ready = function (e) {
+    const _execReady = function () {
+        // eslint-disable-next-line array-callback-return
+        PrimaryCollections_1._QC_READY_LISTENERS.map(function (_ready_listener_, _r) {
+            if (typeof _ready_listener_ === "function") {
+                _ready_listener_();
+                PrimaryCollections_1._QC_READY_LISTENERS.splice(_r, 1);
+            }
+        });
+    };
+    if (CONFIG_1.CONFIG.get("delayForReady") > 0) {
+        if (platform_1.isBrowser) {
+            setTimeout(_execReady.bind(window), CONFIG_1.CONFIG.get("delayForReady"));
+        }
+        else if (typeof global !== "undefined") {
+            setTimeout(_execReady.bind(global), CONFIG_1.CONFIG.get("delayForReady"));
+        }
+    }
+    else {
+        _execReady.call(top_1._top);
+    }
+};
+exports._Ready = _Ready;

package/build/RegisterClass.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterClass = exports.__register_class__ = void 0;
+const getType_1 = require("./getType");
+const make_global_1 = require("./make_global");
+const PrimaryCollections_1 = require("./PrimaryCollections");
+const __register_class__ = function (_class_, __namespace) {
+    let name = _class_.name || (0, getType_1.__getType__)(_class_);
+    if (name.toLowerCase() === "function" && typeof _class_.__classType !== "undefined") {
+        name = _class_.__classType;
+    }
+    if (typeof _class_.__definition === "undefined") {
+        _class_.__definition = {};
+    }
+    _class_.__definition.__classType = name;
+    if (typeof __namespace !== "undefined") {
+        _class_.__definition.__namespace = __namespace;
+    }
+    PrimaryCollections_1._QC_CLASSES[name] = _class_;
+    (0, make_global_1.__make_global__)(PrimaryCollections_1._QC_CLASSES[name]);
+    return PrimaryCollections_1._QC_CLASSES[name];
+};
+exports.__register_class__ = __register_class__;
+const RegisterClass = function (_class_, __namespace) {
+    return (0, exports.__register_class__)(_class_, __namespace);
+};
+exports.RegisterClass = RegisterClass;
+(0, make_global_1.__make_global__)(exports.RegisterClass);

package/build/Service.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = exports.JSONService = exports.Service = void 0;
+const basePath_1 = require("./basePath");
+const Crypt_1 = require("./Crypt");
+const domain_1 = require("./domain");
+const InheritClass_1 = require("./InheritClass");
+const Logger_1 = require("./Logger");
+const Package_1 = require("./Package");
+const secretKey_1 = require("./secretKey");
+const CONFIG_1 = require("./CONFIG");
+class Service extends InheritClass_1.InheritClass {
+    options;
+    withCredentials;
+    useHTTP2;
+    // eslint-disable-next-line no-unused-vars
+    mockup({ request, service }) {
+        throw new Error("Method not implemented.");
+    }
+    name;
+    responseHeaders;
+    // eslint-disable-next-line no-unused-vars
+    local({ request, service }) {
+        throw new Error("Method not implemented.");
+    }
+    kind = "rest";
+    /* it can be rest, mockup, local */
+    domain = domain_1._domain_;
+    basePath = basePath_1._basePath_;
+    url = "";
+    method = "GET";
+    data = {};
+    reload = false;
+    cached = false;
+    headers;
+    template;
+    // eslint-disable-next-line no-unused-vars
+    done({ request, service }) {
+        throw new Error("Method not implemented.");
+    }
+    // eslint-disable-next-line no-unused-vars
+    fail(...args) {
+        throw new Error("Method not implemented.");
+    }
+    set(name, value) {
+        this[name] = value;
+    }
+    get(name, _default) {
+        return this[name] || _default;
+    }
+}
+exports.Service = Service;
+class JSONService extends Service {
+    method = "GET";
+    cached = false;
+    headers = {
+        "Content-Type": "application/json",
+        "charset": "utf-8"
+    };
+    JSONresponse = undefined;
+    done(result) {
+        Logger_1.logger.debug("***** RECEIVED RESPONSE:");
+        Logger_1.logger.debug(result.service.template);
+        this.JSONresponse = JSON.parse(result.service.template);
+    }
+}
+exports.JSONService = JSONService;
+class ConfigService extends JSONService {
+    method = "GET";
+    cached = false;
+    configFileName = "config.json";
+    headers = {
+        "Content-Type": "application/json",
+        "charset": "utf-8"
+    };
+    configLoaded() {
+        throw Error("Method not implemented.");
+    }
+    JSONresponse = undefined;
+    done(result) {
+        Logger_1.logger.debug("***** CONFIG LOADED:");
+        Logger_1.logger.debug(result.service.template);
+        this.JSONresponse = JSON.parse(result.service.template);
+        if (Object.hasOwn(this.JSONresponse, "__encoded__")) {
+            const decodedValue = Crypt_1._Crypt.decrypt(this.JSONresponse?.__encoded__, secretKey_1._secretKey);
+            this.JSONresponse = JSON.parse(decodedValue);
+        }
+        const jsonResponse = this.JSONresponse;
+        Object.keys(jsonResponse).map((k) => {
+            CONFIG_1.CONFIG.set(k, jsonResponse[k]);
+            return k;
+        });
+        this.configLoaded().catch((e) => { throw new Error(`An error ocurred: ${e}`); });
+    }
+    fail() {
+        this.configLoaded().catch((e) => { throw new Error(`An error ocurred: ${e}`); });
+    }
+    constructor() {
+        super();
+        this.set("url", `${this.get("basePath")}${this.get("configFileName")}`);
+    }
+}
+exports.ConfigService = ConfigService;
+(0, Package_1.Package)("com.qcobjects.api", [
+    Service
+]);
+(0, Package_1.Package)("com.qcobjects.api.services", [
+    JSONService
+]);
+(0, Package_1.Package)("com.qcobjects.api.config", [
+    ConfigService
+]);

package/build/SourceCSS.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceCSS = void 0;
+const basePath_1 = require("./basePath");
+const Cast_1 = require("./Cast");
+const domain_1 = require("./domain");
+const DOMCreateElement_1 = require("./DOMCreateElement");
+const InheritClass_1 = require("./InheritClass");
+const platform_1 = require("./platform");
+const Package_1 = require("./Package");
+class SourceCSS extends InheritClass_1.InheritClass {
+    domain = domain_1._domain_;
+    basePath = basePath_1._basePath_;
+    url = "";
+    data = {};
+    async = false;
+    external = false;
+    constructor(o) {
+        super(o);
+        this.body = (0, DOMCreateElement_1._DOMCreateElement)("link");
+    }
+    fail() {
+        throw new Error("Method not implemented.");
+    }
+    Cast(o) {
+        return (0, Cast_1._Cast)(this, o);
+    }
+    set(name, value) {
+        this[name] = value;
+    }
+    get(name, _default) {
+        return this[name] || _default;
+    }
+    done() { }
+    rebuild() {
+        const context = this;
+        if (platform_1.isBrowser) {
+            window.document.getElementsByTagName("head")[0].appendChild((function (s, url, context) {
+                s.type = "text/css";
+                s.rel = "stylesheet";
+                s.href = url;
+                s.crossOrigin = "anonymous";
+                s.onreadystatechange = function () {
+                    if (this.readyState === "complete") {
+                        context.done.call(context);
+                    }
+                };
+                s.onload = context.done;
+                context.body = s;
+                return s;
+            }).call(this, (0, DOMCreateElement_1._DOMCreateElement)("link"), (this.external) ? (this.url) : (this.basePath + this.url), context));
+        }
+    }
+}
+exports.SourceCSS = SourceCSS;
+(0, Package_1.Package)("com.qcobjects", [SourceCSS]);

package/build/SourceJS.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceJS = void 0;
+const basePath_1 = require("./basePath");
+const Cast_1 = require("./Cast");
+const domain_1 = require("./domain");
+const DOMCreateElement_1 = require("./DOMCreateElement");
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+const Logger_1 = require("./Logger");
+class SourceJS extends InheritClass_1.InheritClass {
+    domain = domain_1._domain_;
+    basePath = basePath_1._basePath_;
+    type = "text/javascript";
+    containerTag = "body";
+    url = "";
+    data = {};
+    async = false;
+    external = false;
+    constructor(o) {
+        super(o);
+        this.body = (0, DOMCreateElement_1._DOMCreateElement)("script");
+    }
+    set(name, value) {
+        this[name] = value;
+    }
+    get(name, _default) {
+        return this[name] || _default;
+    }
+    status = false;
+    done() { }
+    fail() { }
+    rebuild() {
+        const context = this;
+        try {
+            document.getElementsByTagName(context.containerTag)[0].appendChild((function (s, url, context) {
+                s.type = context.type;
+                s.src = url;
+                s.crossOrigin = (Object.hasOwn(context, "crossOrigin")) ? (context.crossOrigin) : ("anonymous");
+                s.async = context.async;
+                s.onreadystatechange = function () {
+                    if (this.readyState === "complete") {
+                        context.done.call(context);
+                    }
+                };
+                s.onload = function (e) {
+                    context.status = true;
+                    context.done.call(context, e);
+                };
+                s.onerror = function (e) {
+                    context.status = false;
+                    context.fail.call(context, e);
+                };
+                context.body = s;
+                return s;
+            }).call(this, (0, DOMCreateElement_1._DOMCreateElement)("script"), (this.external) ? (this.url) : (this.basePath + this.url), context));
+        }
+        catch (e) {
+            context.status = false;
+            Logger_1.logger.debug(`An error ocurred: ${e}`);
+            context.fail();
+        }
+    }
+    Cast(o) {
+        return (0, Cast_1._Cast)(this, o);
+    }
+    _new_(properties) {
+        this.__new__(properties);
+        this.rebuild();
+    }
+}
+exports.SourceJS = SourceJS;
+(0, Package_1.Package)("com.qcobjects", [SourceJS]);

package/build/Tag.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tag = exports.TagElements = void 0;
+const ClassFactory_1 = require("./ClassFactory");
+const New_1 = require("./New");
+const Package_1 = require("./Package");
+const platform_1 = require("./platform");
+const ArrayCollection_1 = require("./ArrayCollection");
+class TagElements extends ArrayCollection_1.ArrayList {
+    show() {
+        this.map(function (element) {
+            return element.style.opacity = 1;
+        });
+    }
+    hide() {
+        this.map(function (element) {
+            return element.style.opacity = 0;
+        });
+    }
+    effect(...args) {
+        const effectArguments = [...args].slice(1);
+        const effectClassName = args[0];
+        let effectClass = undefined;
+        if ((typeof effectClassName).toLowerCase() === "string") {
+            effectClass = (0, ClassFactory_1.ClassFactory)(effectClassName);
+        }
+        this.map(function (element) {
+            return effectClass.apply.apply(effectClass, [element].concat(effectArguments));
+        });
+    }
+    findElements(elementName) {
+        const _o = (0, New_1.New)((0, ClassFactory_1.ClassFactory)("TagElements"));
+        if (platform_1.isBrowser) {
+            for (const _k in this) {
+                if (typeof _k === "number" && typeof this[_k] !== "function" && Object.hasOwn(this[_k], "subelements")) {
+                    _o.push(this[_k].subelements(elementName));
+                }
+            }
+        }
+        else {
+            // not yet implemented.
+        }
+        return _o;
+    }
+}
+exports.TagElements = TagElements;
+/**
+ * Gets the element of DOM found by tag name
+ *
+ * @param {Object} tagname
+ * @param {Object} innerHTML
+ */
+const Tag = function (tagname, innerHTML) {
+    const _o = (0, New_1.New)(TagElements);
+    if (platform_1.isBrowser) {
+        const o = document.subelements(tagname);
+        const addedKeys = [];
+        for (let _i = 0; _i < o.length; _i++) {
+            if (typeof innerHTML !== "undefined" && Object.hasOwn(o[_i], "innerHTML")) {
+                o[_i].innerHTML = innerHTML;
+            }
+            if (addedKeys.indexOf(_i) < 0) {
+                _o.push(o[_i]);
+                addedKeys.push(_i);
+            }
+        }
+    }
+    else {
+        // not yet implemented.
+    }
+    return _o;
+};
+exports.Tag = Tag;
+(0, Package_1.Package)("com.qcobjects", [
+    TagElements,
+    exports.Tag
+]);

package/build/Timer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+class Timer extends InheritClass_1.InheritClass {
+    duration = 1000;
+    alive = true;
+    thread({ timing, intervalInterceptor, duration }) {
+        const timer = this;
+        const start = performance.now();
+        requestAnimationFrame(function thread(time) {
+            // timeFraction goes from 0 to 1
+            const elapsed = (time - start);
+            let timeFraction = elapsed / duration;
+            if (timeFraction > 1)
+                timeFraction = 1;
+            // calculate the current progress state
+            const progress = timing(timeFraction, elapsed);
+            intervalInterceptor(Math.round(progress * 100)); // draw it
+            if ((timeFraction < 1 || duration === -1) && timer.alive) {
+                requestAnimationFrame(thread);
+            }
+        });
+    }
+}
+exports.Timer = Timer;
+(0, Package_1.Package)("com.qcobjects.timing", [
+    Timer
+]);

package/build/Toggle.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Toggle = void 0;
+const InheritClass_1 = require("./InheritClass");
+const Logger_1 = require("./Logger");
+const Package_1 = require("./Package");
+class Toggle extends InheritClass_1.InheritClass {
+    _toggle = false;
+    _inverse = true;
+    _positive = null;
+    _negative = null;
+    _dispatched = null;
+    _args = {};
+    constructor(positive, negative, args) {
+        super({ positive, negative, args });
+        this._new_({ positive, negative, args });
+    }
+    changeToggle() {
+        this._toggle = !(this._toggle);
+    }
+    _new_({ positive, negative, args }) {
+        this._positive = positive;
+        this._negative = negative;
+        this._args = args;
+    }
+    fire() {
+        const toggle = this;
+        var _promise = new Promise(function (resolve, reject) {
+            if (typeof toggle._positive === "function" && typeof toggle._negative === "function") {
+                if (toggle._inverse) {
+                    toggle._dispatched = (toggle._toggle) ? (toggle._negative.bind(toggle)) : (toggle._positive.bind(toggle));
+                }
+                else {
+                    toggle._dispatched = (toggle._toggle) ? (toggle._positive.bind(toggle)) : (toggle._negative.bind(toggle));
+                }
+                toggle._dispatched?.call(toggle, toggle._args);
+                resolve.call(_promise, toggle);
+            }
+            else {
+                Logger_1.logger.debug("Toggle functions are not declared");
+                reject.call(_promise, toggle);
+            }
+            return toggle;
+        }).then(function (toggle) {
+            toggle.changeToggle();
+            return toggle;
+        }).catch(function (e) {
+            Logger_1.logger.debug(e.toString());
+            return toggle;
+        }).finally(() => {
+            return toggle;
+        });
+        return _promise;
+    }
+}
+exports.Toggle = Toggle;
+(0, Package_1.Package)("com.qcobjects.tools.essentials", [
+    Toggle
+]);

package/build/TransitionEffect.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionEffect = void 0;
+const Effect_1 = require("./Effect");
+const Logger_1 = require("./Logger");
+const Package_1 = require("./Package");
+const ClassFactory_1 = require("./ClassFactory");
+class TransitionEffect extends Effect_1.Effect {
+    duration = 385;
+    defaultParams = {
+        alphaFrom: 0,
+        alphaTo: 1,
+        angleFrom: 180,
+        angleTo: 0,
+        radiusFrom: 0,
+        radiusTo: 30,
+        scaleFrom: 0,
+        scaleTo: 1
+    };
+    fitToHeight = false;
+    fitToWidth = false;
+    component;
+    effects;
+    apply({ alphaFrom, alphaTo, angleFrom, angleTo, radiusFrom, radiusTo, scaleFrom, scaleTo }) {
+        const _transition_ = this;
+        Logger_1.logger.info("EXECUTING TransitionEffect  ");
+        const componentRoot = _transition_.component.componentRoot;
+        if (typeof componentRoot !== "undefined" && componentRoot !== null) {
+            if (_transition_.fitToHeight) {
+                componentRoot.height = (typeof componentRoot.offsetParent === "object" && componentRoot.offsetParent !== null) ? (componentRoot.offsetParent?.scrollHeight) : (componentRoot.getBoundingClientRect().height);
+            }
+            if (_transition_.fitToWidth) {
+                componentRoot.width = (typeof componentRoot.offsetParent === "object" && componentRoot.offsetParent !== null) ? (componentRoot.offsetParent?.scrollWidth) : (componentRoot.getBoundingClientRect().width);
+            }
+            if (_transition_.component.shadowed) {
+                componentRoot.host.style.display = "block";
+            }
+            else {
+                componentRoot.style.display = "block";
+            }
+            _transition_.effects.map((effectClassName) => {
+                const __effectClass__ = (0, ClassFactory_1.ClassFactory)(effectClassName);
+                const effectObj = new __effectClass__({});
+                const effectClassMethod = effectObj.apply.bind(_transition_);
+                const componentHost = (_transition_.component.shadowed) ? (componentRoot.host) : (componentRoot);
+                const effectParams = {
+                    alphaFrom,
+                    alphaTo,
+                    angleFrom,
+                    angleTo,
+                    radiusFrom,
+                    radiusTo,
+                    scaleFrom,
+                    scaleTo
+                };
+                effectClassMethod(componentHost, ...Object.values(effectParams));
+                return effectClassName;
+            });
+        }
+    }
+}
+exports.TransitionEffect = TransitionEffect;
+(0, Package_1.Package)("com.qcobjects.effects.transitions.base", [
+    TransitionEffect
+]);

package/build/VO.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VO = void 0;
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+class VO extends InheritClass_1.InheritClass {
+}
+exports.VO = VO;
+(0, Package_1.Package)("com.qcobjects.valueObjects", [
+    VO
+]);

package/build/View.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.View = void 0;
+const getType_1 = require("./getType");
+const InheritClass_1 = require("./InheritClass");
+const Package_1 = require("./Package");
+class View extends InheritClass_1.InheritClass {
+    constructor({ component = undefined, dependencies = [] }) {
+        super({ component, dependencies });
+        if (typeof this.component === "undefined" || this.component === "null") {
+            throw Error(`${(0, getType_1.__getType__)(this)} must be called with a component`);
+        }
+    }
+}
+exports.View = View;
+(0, Package_1.Package)("com.qcobjects.views", [
+    View
+]);