qcobjects 2.4.105-ts → 2.4.108-ts

package/src/Import.ts

@@ -0,0 +1,135 @@
+import { _basePath_ } from "./basePath";
+import { CONFIG } from "./CONFIG";
+import { _DataStringify } from "./DataStringify";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { findPackageNodePath } from "./findPackageNodePath";
+import { logger } from "./Logger";
+import { _require_, isBrowser } from "./platform";
+import { _QC_PACKAGES, _QC_PACKAGES_IMPORTED, _QC_READY_LISTENERS } from "./PrimaryCollections";
+
+/**
+ * Imports a script with the package nomenclature
+ *
+ * @param {Object} packagename
+ * @param {Object} ready
+ * @param {Boolean} external
+ */
+export const Import = function (packagename:string, ready?:Function, external?:boolean):Promise<{_imported_?:any, _package_name_?:string}> | undefined {
+
+    if (external !== undefined){
+        logger.debug(`[Import] Setting external=${external.toString()} resource to import: ${packagename}`);
+    }    
+    if (external) {
+        logger.debug(`[Import] Registering external resource to import: ${packagename}`);
+    } else {
+        logger.debug(`[Import] Registering local resource to import: ${packagename}`);
+    }
+    let _promise_import_: Promise<any>;
+    if (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 _QC_PACKAGES) {
+                    cp++;
+                }
+                if (cp < _QC_PACKAGES_IMPORTED.length) {
+                    ret = false;
+                } else {
+                    ret = true;
+                }
+                return ret;
+            };
+
+            const readyImported = function (e: { target: { remove: () => void; }; }) {
+                _QC_PACKAGES_IMPORTED.push(ready as never);
+                if (allPackagesImported()) {
+                    _QC_PACKAGES_IMPORTED.map(function (_imported_) {
+                        _QC_READY_LISTENERS.push(_imported_);
+                    });
+                }
+                if (isBrowser && CONFIG.get("removePackageScriptAfterLoading")) {
+                    e.target.remove();
+                }
+                resolve.call(_promise_import_, {
+                    "_imported_": e.target,
+                    "_package_name_": packagename
+                });
+            };
+
+            if (!Object.hasOwn(_QC_PACKAGES, packagename)) {
+                const s1:HTMLScriptElement = _DOMCreateElement("script") as unknown as HTMLScriptElement;
+                s1.type = CONFIG.get("sourceType", "text/javascript");
+                s1.async = !!(CONFIG.get("asynchronousImportsLoad"));
+                (s1 as any).onreadystatechange = function () {
+                    if ((s1 as any).readyState === "complete") {
+                        readyImported(s1 as any);
+                    }
+                };
+                (s1 as any).onload = readyImported;
+                s1.onerror = function (e: any) {
+                    logger.debug(`An error ocurred: ${e}.`);
+                    reject.call(_promise_import_, {
+                        "_imported_": s1,
+                        "_package_name_": packagename
+                    });
+                };
+                s1.src = (external) ? (CONFIG.get("remoteImportsPath") + packagename + ".js") : (_basePath_ + CONFIG.get("relativeImportPath") + packagename + ".js");
+                document.getElementsByTagName("head")[0].appendChild(s1);
+            }
+        });
+        _promise_import_.catch(function () {
+            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 = findPackageNodePath(packagename);
+                let packageAbsoluteName = "";
+                if (standardNodePath !== null) {
+                    packageAbsoluteName = standardNodePath + "/" + packagename;
+                } else {
+                    const jsNodePath = findPackageNodePath(packagename + ".js");
+                    if (jsNodePath !== null) {
+                        packageAbsoluteName = jsNodePath + "/" + packagename + ".js";
+                    } else {
+                        packageAbsoluteName = _basePath_ + CONFIG.get("relativeImportPath") + packagename;
+                    }
+                }
+                try {
+                    resolve.call(_promise_import_, {
+                        "_imported_": _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.debug("Something happened when importing " + packagename);
+            console.warn(e);
+        });
+    }
+    _promise_import_.catch(function (e) {
+        logger.warn(_DataStringify(e));
+    });
+    return _promise_import_;
+};
+Import.prototype.toString = function () {
+    return "Import(packagename,ready,external) { [QCObjects native code] }";
+};

package/src/IncrementInstanceID.ts

@@ -0,0 +1,8 @@
+/**
+ * Primary instance ID of all objects
+ */
+export var __instanceID = 0;
+
+export const IncrementInstanceID = () => {
+    __instanceID = (typeof __instanceID === "undefined" || __instanceID === null) ? (0) : (__instanceID + 1);
+};

package/src/InheritClass.ts

@@ -0,0 +1,210 @@
+import { type IInheritClass, type IQCObjectsElement, type TBody } from "types";
+import { logger } from "./Logger";
+import { __instanceID, IncrementInstanceID } from "./IncrementInstanceID";
+import { _CastProps, _Cast } from "./Cast";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { __getType__ } from "./getType";
+import { _methods_ } from "./introspection";
+import { is_a } from "./is_a";
+import { isBrowser } from "./platform";
+import { _QC_CLASSES } from "./PrimaryCollections";
+import { Package } from "./Package";
+
+export class InheritClass implements IInheritClass {
+    [key: string]: any;
+    __definition: any;
+    private _body: TBody;
+    public get body(): TBody {
+        return this._body;
+    }
+    public set body(value: TBody) {
+        this._body = value;
+    }
+    childs: any;
+    __instanceID!: number;
+
+    constructor(_o_?: any) {
+
+        if (typeof _o_ !== "undefined" && typeof _o_.__definition !== "undefined"){
+            this.__definition = {
+                ...(_o_.__definition)
+            };
+        }
+
+        const self:any = this;
+        IncrementInstanceID();
+        if (!self.__instanceID) {
+            Object.defineProperty(self, "__instanceID", {
+                value: __instanceID,
+                writable: false
+            });
+        }
+
+        if (typeof self.__definition !== "undefined") {
+            Object.keys(self.__definition).filter(function (k) {
+                return isNaN(k as any) && !["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];
+                }
+            });
+        }
+        _methods_((_QC_CLASSES as any)[self.__classType]).map(function (m): any {
+            self[(m as Function).name] = (m as Function).bind(self);
+            return m;
+        });
+        _methods_(self.__definition).map(function (m): any {
+            self[(m as Function).name] = (m as Function).bind(self);
+            return m;
+        });
+
+        if (self.body) {
+            if (typeof self.__definition === "undefined" || (!Object.hasOwn(self.__definition, "body")) || typeof self.__definition.body === "undefined") {
+                try {
+                    if (isBrowser) {
+                        self.body = _DOMCreateElement(self.__definition.__classType);
+                    } else {
+                        self.body = {};
+                    }
+                } catch (e:any) {
+                    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: any) {
+                    logger.warn(`${self.__classType}._new_() failed with error: ${e}`);
+                }
+            }
+        } catch (e: any) {
+            logger.warn(e);
+        }
+    }
+
+    static get __classType(): any {
+        return (Object.getPrototypeOf(this.constructor) as Function).name;
+    }
+
+    get __classType(): string {
+        return this.constructor.name;
+    }
+
+
+    static hierarchy(__class__: any): any[] {
+        const __classType = function (o_c: any): any {
+            return (Object.hasOwn(o_c, "__classType")) ? (o_c.__classType) : (__getType__.call(__class__, o_c));
+        };
+        const __hierarchy__proto__ = (c: any): any[] => {
+            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?: string | undefined;
+
+    __new__(_o_: any) {
+        _CastProps(_o_, this);
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    _new_(_o_?: any) { }
+
+    static getParentClass(): any {
+        return Object.getPrototypeOf(this.prototype.constructor);
+    }
+    getParentClass():any {
+        return (this.constructor as typeof InheritClass).getParentClass();
+    }
+
+    
+    static getClass(): any {
+        return Object.getPrototypeOf(this.constructor);
+    }
+
+    getClass(): any {
+        return (this.constructor as typeof InheritClass).getClass();
+    }    
+
+    css(_css: any): any {
+        if (typeof this.body !== "undefined" && typeof this?.body !== "string" && typeof (this?.body as HTMLElement)?.style !== "undefined") {
+            logger.debug("body style");
+            if (this.body){
+                (this.body as any).style = _Cast(_css, (this?.body as HTMLElement)?.style);
+            }
+        }
+        return (typeof this.body !== "string")? (this?.body as HTMLElement)?.style :{};
+    }
+
+    hierarchy(): any {
+        const __instance__ = this;
+        return this.getClass().hierarchy(__instance__);
+    }
+
+
+    append(_child?: any) {
+        const child: any = _child || this.body;
+        logger.debug("append: start");
+        if (is_a(child, "Component")) {
+            logger.debug("append: child is a Component");
+            logger.debug(`appending the body of ${child.name}`);
+        }
+        if (typeof this.body !== "undefined") {
+            logger.debug("append element");
+            if (arguments.length > 0) {
+                logger.debug("append to element");
+                if (typeof this.body !== "string"){
+                    if (typeof (this.body as IQCObjectsElement)?.append !== "undefined") {
+                        (this?.body as IQCObjectsElement)?.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 (isBrowser) {
+                    logger.debug("append to body");
+                    document.body.append(child);
+                }
+            }
+        }
+    }
+
+    attachIn(tag: any) {
+        if (isBrowser) {
+            const tags = (document as any).subelements(tag);
+            for (let i = 0, j = tags.length; i < j; i++) {
+                tags[i].append(this as any);
+            }
+        } else {
+            throw new Error("attachIn not yet implemented for non browser platforms");
+        }
+    }
+
+}
+
+Package("com.qcobjects", [InheritClass]);

package/src/LegacyCopy.ts

@@ -0,0 +1,27 @@
+import { __is_raw_class__ } from "./is_raw_class";
+
+export const _LegacyCopy = function (obj:any, _ignore?:string[]):any {
+    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 as never]:obj[k as never]}; })
+        .reduce ((p, c) => Object.assign(p, c)) as any;
+        break;
+      case typeof obj === "function":
+        _value_ = obj.bind({});
+        break;
+      case __is_raw_class__(obj):
+        _value_ = class extends obj { };
+        break;
+      default:
+        break;
+    }
+    return _value_;
+  };

package/src/Logger.ts

@@ -0,0 +1,32 @@
+import { isBrowser } from "./platform";
+
+export class Logger {
+    debugEnabled = true;
+    infoEnabled = true;
+    warnEnabled = true;
+    debug(message:string) {
+        if (this.debugEnabled) {
+            console.log("\x1b[35m%s\x1b[0m", `[DEBUG][${performance.now().toLocaleString()}] ${message}`);
+        }
+    }
+
+    info(message:string) {
+        let color;
+        if (this.infoEnabled) {
+            if (isBrowser) {
+                color = "\x1b[103m%s\x1b[0m";
+            } else {
+                color = "\x1b[33m%s\x1b[0m";
+            }
+            console.info(color, `[INFO][${performance.now().toLocaleString()}] ${message}`);
+        }
+    }
+
+    warn(message:string) {
+        if (this.warnEnabled) {
+            console.warn("\x1b[31m%s\x1b[0m", `[WARN][${performance.now().toLocaleString()}] ${message}`);
+        }
+    }
+}
+
+export const logger = new Logger();