qcobjects 2.4.107-ts → 2.4.108-ts

package/build/Import.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Import = void 0;
+const basePath_1 = require("./basePath");
+const CONFIG_1 = require("./CONFIG");
+const DataStringify_1 = require("./DataStringify");
+const DOMCreateElement_1 = require("./DOMCreateElement");
+const findPackageNodePath_1 = require("./findPackageNodePath");
+const Logger_1 = require("./Logger");
+const platform_1 = require("./platform");
+const PrimaryCollections_1 = require("./PrimaryCollections");
+/**
+ * Imports a script with the package nomenclature
+ *
+ * @param {Object} packagename
+ * @param {Object} ready
+ * @param {Boolean} external
+ */
+const Import = function (packagename, ready, external) {
+    if (external !== undefined) {
+        Logger_1.logger.debug(`[Import] Setting external=${external.toString()} resource to import: ${packagename}`);
+    }
+    if (external) {
+        Logger_1.logger.debug(`[Import] Registering external resource to import: ${packagename}`);
+    }
+    else {
+        Logger_1.logger.debug(`[Import] Registering local resource to import: ${packagename}`);
+    }
+    let _promise_import_;
+    if (platform_1.isBrowser) {
+        _promise_import_ = new Promise(function (resolve, reject) {
+            const allPackagesImported = function () {
+                let ret = false;
+                let cp = 0;
+                // eslint-disable-next-line no-unused-vars
+                for (const p in PrimaryCollections_1._QC_PACKAGES) {
+                    cp++;
+                }
+                if (cp < PrimaryCollections_1._QC_PACKAGES_IMPORTED.length) {
+                    ret = false;
+                }
+                else {
+                    ret = true;
+                }
+                return ret;
+            };
+            const readyImported = function (e) {
+                PrimaryCollections_1._QC_PACKAGES_IMPORTED.push(ready);
+                if (allPackagesImported()) {
+                    PrimaryCollections_1._QC_PACKAGES_IMPORTED.map(function (_imported_) {
+                        PrimaryCollections_1._QC_READY_LISTENERS.push(_imported_);
+                    });
+                }
+                if (platform_1.isBrowser && CONFIG_1.CONFIG.get("removePackageScriptAfterLoading")) {
+                    e.target.remove();
+                }
+                resolve.call(_promise_import_, {
+                    "_imported_": e.target,
+                    "_package_name_": packagename
+                });
+            };
+            if (!Object.hasOwn(PrimaryCollections_1._QC_PACKAGES, packagename)) {
+                const s1 = (0, DOMCreateElement_1._DOMCreateElement)("script");
+                s1.type = CONFIG_1.CONFIG.get("sourceType", "text/javascript");
+                s1.async = !!(CONFIG_1.CONFIG.get("asynchronousImportsLoad"));
+                s1.onreadystatechange = function () {
+                    if (s1.readyState === "complete") {
+                        readyImported(s1);
+                    }
+                };
+                s1.onload = readyImported;
+                s1.onerror = function (e) {
+                    Logger_1.logger.debug(`An error ocurred: ${e}.`);
+                    reject.call(_promise_import_, {
+                        "_imported_": s1,
+                        "_package_name_": packagename
+                    });
+                };
+                s1.src = (external) ? (CONFIG_1.CONFIG.get("remoteImportsPath") + packagename + ".js") : (basePath_1._basePath_ + CONFIG_1.CONFIG.get("relativeImportPath") + packagename + ".js");
+                document.getElementsByTagName("head")[0].appendChild(s1);
+            }
+        });
+        _promise_import_.catch(function () {
+            Logger_1.logger.debug("Import: Error loading a package ");
+        });
+    }
+    else {
+        // support to be used in a nodejs environment
+        _promise_import_ = new Promise(function (resolve, reject) {
+            try {
+                const standardNodePath = (0, findPackageNodePath_1.findPackageNodePath)(packagename);
+                let packageAbsoluteName = "";
+                if (standardNodePath !== null) {
+                    packageAbsoluteName = standardNodePath + "/" + packagename;
+                }
+                else {
+                    const jsNodePath = (0, findPackageNodePath_1.findPackageNodePath)(packagename + ".js");
+                    if (jsNodePath !== null) {
+                        packageAbsoluteName = jsNodePath + "/" + packagename + ".js";
+                    }
+                    else {
+                        packageAbsoluteName = basePath_1._basePath_ + CONFIG_1.CONFIG.get("relativeImportPath") + packagename;
+                    }
+                }
+                try {
+                    resolve.call(_promise_import_, {
+                        "_imported_": (0, platform_1._require_)(`${packageAbsoluteName}`),
+                        "_package_name_": packagename
+                    });
+                }
+                catch (e) {
+                    reject.call(_promise_import_, {
+                        "_imported_": null,
+                        "_package_name_": packagename,
+                        "error": e
+                    });
+                }
+            }
+            catch (e) {
+                reject.call(_promise_import_, {
+                    "_imported_": null,
+                    "_package_name_": packagename,
+                    "error": e
+                });
+            }
+        }).catch(function (e) {
+            // something wrong importing a package
+            Logger_1.logger.debug("Something happened when importing " + packagename);
+            console.warn(e);
+        });
+    }
+    _promise_import_.catch(function (e) {
+        Logger_1.logger.warn((0, DataStringify_1._DataStringify)(e));
+    });
+    return _promise_import_;
+};
+exports.Import = Import;
+exports.Import.prototype.toString = function () {
+    return "Import(packagename,ready,external) { [QCObjects native code] }";
+};

package/build/IncrementInstanceID.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementInstanceID = exports.__instanceID = void 0;
+/**
+ * Primary instance ID of all objects
+ */
+exports.__instanceID = 0;
+const IncrementInstanceID = () => {
+    exports.__instanceID = (typeof exports.__instanceID === "undefined" || exports.__instanceID === null) ? (0) : (exports.__instanceID + 1);
+};
+exports.IncrementInstanceID = IncrementInstanceID;

package/build/InheritClass.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InheritClass = void 0;
+const Logger_1 = require("./Logger");
+const IncrementInstanceID_1 = require("./IncrementInstanceID");
+const Cast_1 = require("./Cast");
+const DOMCreateElement_1 = require("./DOMCreateElement");
+const getType_1 = require("./getType");
+const introspection_1 = require("./introspection");
+const is_a_1 = require("./is_a");
+const platform_1 = require("./platform");
+const PrimaryCollections_1 = require("./PrimaryCollections");
+const Package_1 = require("./Package");
+class InheritClass {
+    __definition;
+    _body;
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+    }
+    childs;
+    __instanceID;
+    constructor(_o_) {
+        if (typeof _o_ !== "undefined" && typeof _o_.__definition !== "undefined") {
+            this.__definition = {
+                ...(_o_.__definition)
+            };
+        }
+        const self = this;
+        (0, IncrementInstanceID_1.IncrementInstanceID)();
+        if (!self.__instanceID) {
+            Object.defineProperty(self, "__instanceID", {
+                value: IncrementInstanceID_1.__instanceID,
+                writable: false
+            });
+        }
+        if (typeof self.__definition !== "undefined") {
+            Object.keys(self.__definition).filter(function (k) {
+                return isNaN(k) && !["name", "__instanceID", "__classType", "__definition"].includes(k);
+            }).forEach(function (key) {
+                if (typeof self.__definition[key] === "function") {
+                    self[key] = self.__definition[key].bind(self);
+                }
+                else {
+                    self[key] = self.__definition[key];
+                }
+            });
+        }
+        (0, introspection_1._methods_)(PrimaryCollections_1._QC_CLASSES[self.__classType]).map(function (m) {
+            self[m.name] = m.bind(self);
+            return m;
+        });
+        (0, introspection_1._methods_)(self.__definition).map(function (m) {
+            self[m.name] = m.bind(self);
+            return m;
+        });
+        if (self.body) {
+            if (typeof self.__definition === "undefined" || (!Object.hasOwn(self.__definition, "body")) || typeof self.__definition.body === "undefined") {
+                try {
+                    if (platform_1.isBrowser) {
+                        self.body = (0, DOMCreateElement_1._DOMCreateElement)(self.__definition.__classType);
+                    }
+                    else {
+                        self.body = {};
+                    }
+                }
+                catch (e) {
+                    Logger_1.logger.debug(`An error ocurred: ${e}.`);
+                    self.body = {};
+                }
+            }
+            else if (Object.hasOwn(self.__definition, "body")) {
+                self.body = self.__definition.body;
+            }
+        }
+        try {
+            self.__new__.call(self, _o_);
+            if (typeof self === "object" && Object.hasOwn(self, "_new_") && typeof self._new_.isCalled === "undefined") {
+                try {
+                    self._new_(_o_);
+                    self._new_.isCalled = true;
+                }
+                catch (e) {
+                    Logger_1.logger.warn(`${self.__classType}._new_() failed with error: ${e}`);
+                }
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn(e);
+        }
+    }
+    static get __classType() {
+        return Object.getPrototypeOf(this.constructor).name;
+    }
+    get __classType() {
+        return this.constructor.name;
+    }
+    static hierarchy(__class__) {
+        const __classType = function (o_c) {
+            return (Object.hasOwn(o_c, "__classType")) ? (o_c.__classType) : (getType_1.__getType__.call(__class__, o_c));
+        };
+        const __hierarchy__proto__ = (c) => {
+            return (typeof c !== "undefined" && typeof c.__proto__ !== "undefined" && c.__proto__ !== null) ? (((__classType(c) !== "") ? ([__classType(c)]) : ([])).concat(__hierarchy__proto__(c.__proto__))) : ([]);
+        };
+        if (typeof __class__ === "undefined" || __class__ === null) {
+            __class__ = this;
+        }
+        let __hierarchy = [];
+        __hierarchy.push(__classType(__class__));
+        __hierarchy = __hierarchy.concat(__hierarchy__proto__(__class__.__proto__));
+        return __hierarchy;
+    }
+    __namespace;
+    __new__(_o_) {
+        (0, Cast_1._CastProps)(_o_, this);
+    }
+    // eslint-disable-next-line no-unused-vars
+    _new_(_o_) { }
+    static getParentClass() {
+        return Object.getPrototypeOf(this.prototype.constructor);
+    }
+    getParentClass() {
+        return this.constructor.getParentClass();
+    }
+    static getClass() {
+        return Object.getPrototypeOf(this.constructor);
+    }
+    getClass() {
+        return this.constructor.getClass();
+    }
+    css(_css) {
+        if (typeof this.body !== "undefined" && typeof this?.body !== "string" && typeof this?.body?.style !== "undefined") {
+            Logger_1.logger.debug("body style");
+            if (this.body) {
+                this.body.style = (0, Cast_1._Cast)(_css, this?.body?.style);
+            }
+        }
+        return (typeof this.body !== "string") ? this?.body?.style : {};
+    }
+    hierarchy() {
+        const __instance__ = this;
+        return this.getClass().hierarchy(__instance__);
+    }
+    append(_child) {
+        const child = _child || this.body;
+        Logger_1.logger.debug("append: start");
+        if ((0, is_a_1.is_a)(child, "Component")) {
+            Logger_1.logger.debug("append: child is a Component");
+            Logger_1.logger.debug(`appending the body of ${child.name}`);
+        }
+        if (typeof this.body !== "undefined") {
+            Logger_1.logger.debug("append element");
+            if (arguments.length > 0) {
+                Logger_1.logger.debug("append to element");
+                if (typeof this.body !== "string") {
+                    if (typeof this.body?.append !== "undefined") {
+                        this?.body?.append(child);
+                    }
+                    else {
+                        throw Error("body.append is undefined. That means the body is not well formed.");
+                    }
+                }
+                else {
+                    this.append(child);
+                }
+                if (typeof this.childs === "undefined") {
+                    this.childs = [];
+                }
+                this.childs.push(child);
+            }
+            else {
+                if (platform_1.isBrowser) {
+                    Logger_1.logger.debug("append to body");
+                    document.body.append(child);
+                }
+            }
+        }
+    }
+    attachIn(tag) {
+        if (platform_1.isBrowser) {
+            const tags = document.subelements(tag);
+            for (let i = 0, j = tags.length; i < j; i++) {
+                tags[i].append(this);
+            }
+        }
+        else {
+            throw new Error("attachIn not yet implemented for non browser platforms");
+        }
+    }
+}
+exports.InheritClass = InheritClass;
+(0, Package_1.Package)("com.qcobjects", [InheritClass]);

package/build/LegacyCopy.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._LegacyCopy = void 0;
+const is_raw_class_1 = require("./is_raw_class");
+const _LegacyCopy = function (obj, _ignore) {
+    let _value_;
+    switch (true) {
+        case typeof obj === "string":
+            _value_ = obj;
+            break;
+        case typeof obj === "number":
+            _value_ = obj;
+            break;
+        case typeof obj === "object":
+            _value_ = [{ ...Object.keys(obj).filter(k => !_ignore?.includes(k)) }]
+                .map(k => { return { [k]: obj[k] }; })
+                .reduce((p, c) => Object.assign(p, c));
+            break;
+        case typeof obj === "function":
+            _value_ = obj.bind({});
+            break;
+        case (0, is_raw_class_1.__is_raw_class__)(obj):
+            _value_ = class extends obj {
+            };
+            break;
+        default:
+            break;
+    }
+    return _value_;
+};
+exports._LegacyCopy = _LegacyCopy;

package/build/Logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+const platform_1 = require("./platform");
+class Logger {
+    debugEnabled = true;
+    infoEnabled = true;
+    warnEnabled = true;
+    debug(message) {
+        if (this.debugEnabled) {
+            console.log("\x1b[35m%s\x1b[0m", `[DEBUG][${performance.now().toLocaleString()}] ${message}`);
+        }
+    }
+    info(message) {
+        let color;
+        if (this.infoEnabled) {
+            if (platform_1.isBrowser) {
+                color = "\x1b[103m%s\x1b[0m";
+            }
+            else {
+                color = "\x1b[33m%s\x1b[0m";
+            }
+            console.info(color, `[INFO][${performance.now().toLocaleString()}] ${message}`);
+        }
+    }
+    warn(message) {
+        if (this.warnEnabled) {
+            console.warn("\x1b[31m%s\x1b[0m", `[WARN][${performance.now().toLocaleString()}] ${message}`);
+        }
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();