qcobjects 2.5.115-beta → 2.5.118-beta

package/src/ObjectName.ts

@@ -1,16 +1,16 @@
-    /**
-     * Returns the object or function name
-     *
-     * @param Object or function
-     */
-    export const ObjectName = function (o:any) {
-        let ret = "";
-        if (typeof o === "function" && Object.hasOwn(o, "name") && o.name !== "") {
-          ret = o.name;
-        } else if (typeof o !== "undefined" && typeof o.constructor === "function" && o.constructor.name !== "") {
-          ret = o.constructor.name;
-        } else if (typeof o !== "undefined" && typeof o.constructor === "object") {
-          ret = o.constructor.toString().replace(/\[(.*?)\]/g, "$1").split(" ").slice(1).join("");
-        }
-        return ret;
-      };
+/**
+ * Returns the object or function name
+ *
+ * @param Object or function
+ */
+export const ObjectName = function (o: any) {
+  let ret = "";
+  if (typeof o === "function" && Object.hasOwn(o, "name") && o.name !== "") {
+    ret = o.name;
+  } else if (typeof o !== "undefined" && typeof o.constructor === "function" && o.constructor.name !== "") {
+    ret = o.constructor.name;
+  } else if (typeof o !== "undefined" && typeof o.constructor === "object") {
+    ret = o.constructor.toString().replace(/\[(.*?)\]/g, "$1").split(" ").slice(1).join("");
+  }
+  return ret;
+};

package/src/Package.ts

@@ -1,7 +1,5 @@
-import { InheritClass } from "./InheritClass";
 import { __is_raw_class__ } from "./is_raw_class";
-import { _QC_PACKAGES } from "./PrimaryCollections";
-import { __register_class__ } from "./RegisterClass";
+import {_QC_PACKAGES, set_QC_PACKAGE, __register_class__ } from "./PrimaryCollections";
 
 /**
  * Defines a package for Class classification
@@ -9,59 +7,39 @@ import { __register_class__ } from "./RegisterClass";
  * @param {Object} namespace
  * @param {Object} classes
  */
-export const Package = function (namespace: string, classes: any[] = []): any[] | undefined {
+export const Package = (namespace: string, classes: any[] = []): any[] => {
+
   if (Object.hasOwn(_QC_PACKAGES, namespace) &&
-    typeof (_QC_PACKAGES as any)[namespace] !== "undefined" &&
-    Object.hasOwn((_QC_PACKAGES as any)[namespace], "length") &&
-    (_QC_PACKAGES as any)[namespace].length > 0 &&
+    typeof _QC_PACKAGES[namespace] !== "undefined" &&
+    typeof _QC_PACKAGES[namespace] !== "string" &&
+    Object.hasOwn(_QC_PACKAGES[namespace], "length") &&
+    _QC_PACKAGES[namespace].length > 0 &&
     typeof classes !== "undefined" &&
     Object.hasOwn(classes, "length") &&
     classes.length > 0
   ) {
-    classes.filter(
-      function (_c1) {
-        return __is_raw_class__(_c1);
-      }
-    ).map(<T>(_class_: any): T => {
-      if (typeof _class_.__definition === "undefined") {
-        _class_.__definition = {};
-      }
-    _class_.__definition.__namespace = namespace;
-      _class_.__namespace = namespace;
-      return _class_ as T;
+    classes.forEach((_class_: any) => {
+      __register_class__(_class_, namespace);
     });
-    (_QC_PACKAGES as any)[namespace] = (_QC_PACKAGES as any)[namespace].concat(classes);
-  } else if (typeof classes !== "undefined") {
-    if (typeof classes === "object" && Object.hasOwn(classes, "length")) {
-      classes.filter(
-        function (_c1) {
-          return __is_raw_class__(_c1);
-        }
-      ).map(<T>(_class_: any): T => {
-        if (typeof _class_.__definition === "undefined") {
-          _class_.__definition = {};
-        }
-        _class_.__definition.__namespace = namespace;
-        _class_.__namespace = namespace;
-        return _class_ as T;
-      });
-    } else if ((classes as any).prototype instanceof InheritClass) {
-      if (typeof (classes as any).__definition === "undefined") {
-        (classes as any).__definition = {};
-      }
-    (classes as any).__definition.__namespace = namespace;
-      (classes as any).__namespace = namespace;
-    }
-    (_QC_PACKAGES as any)[namespace] = classes;
-  }
-  if (Object.hasOwn(_QC_PACKAGES, namespace)) {
-    (_QC_PACKAGES as any)[namespace].map(<T>(_class_: any): T => {
+    set_QC_PACKAGE(namespace, _QC_PACKAGES[namespace].concat(classes));
+  } else if (typeof classes !== "undefined"
+    && typeof classes !== "undefined"
+    && Object.hasOwn(classes, "length")
+    && classes.length > 0) {
+    classes.forEach((_class_: any) => {
       __register_class__(_class_, namespace);
-      return _class_ as T;
     });
+    set_QC_PACKAGE(namespace, classes);
+  } else if (__is_raw_class__(classes)) {
+    if (typeof (classes as any).__definition === "undefined") {
+      (classes as any).__definition = {};
+    }
+    (classes as any).__definition.__namespace = namespace;
+    (classes as any).__namespace = namespace;
+    __register_class__(classes, namespace);
+    set_QC_PACKAGE(namespace, [classes]);
+  } else {
+    throw new Error (`An error ocurred. It was not possible to add classes to ${namespace}.`);
   }
-  return ((Object.hasOwn(_QC_PACKAGES, namespace)) ? ((_QC_PACKAGES as any)[namespace]) : (undefined)) as any[] | undefined;
+  return ((Object.hasOwn(_QC_PACKAGES, namespace)) ? (_QC_PACKAGES[namespace]) : []) as any[] | [];
 };
-Package.prototype.toString = function () {
-  return "Package(namespace, classes) { [QCObjects native code] }";
-};

package/src/PrimaryCollections.ts

@@ -1,7 +1,98 @@
 import { T_QC_CLASSES, T_QC_PACKAGES } from "types";
+import { __getType__ } from "./getType";
+import { __make_global__ } from "./make_global";
 
-export var _QC_CLASSES:T_QC_CLASSES = {};
-export var _QC_PACKAGES:T_QC_PACKAGES = {};
-export var _QC_PACKAGES_IMPORTED:any[] = [];
-export var _QC_READY_LISTENERS:any[] = [];
+export var _QC_CLASSES: T_QC_CLASSES = {};
+export var _QC_PACKAGES: T_QC_PACKAGES = {};
+export var _QC_PACKAGES_IMPORTED: any[] = [];
+export var _QC_READY_LISTENERS: any[] = [];
+
+export const __register_class__ = function (_class_: any, __namespace?: string): any {
+    const __classType = __getType__(_class_);
+    let name = _class_.name || __classType;
+    if (name.toLowerCase() === "function") {
+        name = __classType;
+    }
+    if (typeof _class_.__definition === "undefined") {
+        _class_.__definition = {};
+    }
+    _class_.__definition.__classType = __classType;
+    if (typeof __namespace !== "undefined") {
+        _class_.__definition.__namespace = __namespace;
+    }
+    _QC_CLASSES[name] = _class_;
+    __make_global__(_class_);
+    return _QC_CLASSES[name];
+};
+
+export const get_QC_CLASS = (name:string):any => {
+    return _QC_CLASSES[name];
+};
+
+const _get_packages_names = function <T>(_packages: any): T[] {
+    let _keys: any[] = [];
+    for (const _k of Object.keys(_packages)) {
+        if (
+            typeof _packages[_k] !== "undefined" &&
+            typeof _packages[_k] !== "function" &&
+            Object.hasOwn(_packages[_k], "length") &&
+            _packages[_k].length > 0
+        ) {
+            _keys.push(_k);
+            _keys = _keys.concat(_get_packages_names(_packages[_k]));
+        }
+    }
+    return _keys as T[];
+};
+
+
+export const getPackagesNamesList = (): any[] => {
+    return _get_packages_names(_QC_PACKAGES);
+};
+
+export const getPackagesList = (): any[] => {
+    return [...getPackagesNamesList()].map(<T>(packagename: string): T => {
+        const _classesList: any[] = _QC_PACKAGES[packagename] as any[];
+        let _ret_: any = undefined;
+        if (_classesList) {
+            _ret_ = {
+                packageName: packagename,
+                classesList: _classesList.filter(function (): boolean {
+                    return true;
+                })
+            };
+        }
+        return _ret_ as T;
+    }).filter(function (_p: any): boolean {
+        return typeof _p !== "undefined";
+    });
+};
+
+export const getClassesList = (): any[] => {
+    let _classesList: any[] = [];
+    [...getPackagesList()].forEach(function <T>(_package_element: any): T {
+        _classesList = _classesList.concat(_package_element.classesList.map(
+            (_class_element: any) => {
+                return {
+                    packageName: _package_element.packageName,
+                    className: `${_package_element.packageName}.${__getType__(_class_element)}`,
+                    classFactory: _class_element
+                };
+            }
+        ));
+        return _package_element as T;
+    });
+
+    return _classesList;
+};
+
+export const getClassesNamesList = (): any[] => {
+    return [...getClassesList()].map(<T>(_class_element: any): T => {
+        return _class_element.className as T;
+    });
+};
+
+export const set_QC_PACKAGE = (packageName: string, _qc_packages: any[]) => {
+    _QC_PACKAGES[packageName] = _qc_packages;
+};
 

package/src/QCObjects.ts

@@ -33,6 +33,8 @@
 
 export * as AssignPolyfill from "./assign";
 export * as __top__ from "./top";
+export * as QCObjects from "./MainProcess";
+
 export {_top, resetTop} from "./top";
 export { _QC_CLASSES, _QC_PACKAGES, _QC_PACKAGES_IMPORTED, _QC_READY_LISTENERS } from "./PrimaryCollections";
 export { _DataStringify } from "./DataStringify";
@@ -99,4 +101,3 @@ export { __to_number } from "./mathFunctions";
 export {_top as global} from "./top";
 export {__make_global__} from "./make_global";
 export {get, set} from "./top";
-export * as QCObjects from "./MainProcess";

package/src/RegisterClass.ts

@@ -1,24 +1,7 @@
-import { __getType__ } from "./getType";
 import { __make_global__ } from "./make_global";
-import { _QC_CLASSES } from "./PrimaryCollections";
+import { __register_class__ } from "./PrimaryCollections";
 
 
-export const __register_class__ = function (_class_:any, __namespace?:string):any {
-    let name = _class_.name || __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;
-    }
-    (_QC_CLASSES as any)[name] = _class_;
-    __make_global__((_QC_CLASSES as any)[name]);
-    return (_QC_CLASSES as any)[name];
-};
 
 export const RegisterClass = function (_class_:any, __namespace?:string):any {
     return __register_class__(_class_, __namespace);

package/src/findPackageNodePath.ts

@@ -1,17 +1,14 @@
-import { _import_ } from "./_import_";
 import { CONFIG } from "./CONFIG";
 import { Export } from "./Export";
 import { logger } from "./Logger";
 import { isBrowser } from "./platform";
 
 export const findPackageNodePath = function (packagename:string):string|null {
-    
     let sdkPath = null;
     if (!isBrowser) {
-        let fs:any;
-        (async () => {
-            fs = await _import_("node:fs");
-        })().then(() => {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require("fs");
+        try {
             let sdkPaths = [
                 `${CONFIG.get("projectPath")}${CONFIG.get("relativeImportPath")}`,
                 `${CONFIG.get("basePath")}${CONFIG.get("relativeImportPath")}`,
@@ -36,11 +33,11 @@ export const findPackageNodePath = function (packagename:string):string|null {
                 sdkPath = "";
                 logger.info(`${packagename} is not in a standard path.`);
             }
+        } catch (e) {
+            // do nothing
+            console.log(e);
+        }
 
-        })
-        .catch((e:any) => {
-            throw new Error(e);
-        });
     }
     return sdkPath;
 };

package/src/getType.ts

@@ -1,36 +1,35 @@
 import { __is_raw_class__ } from "./is_raw_class";
 import { ObjectName } from "./ObjectName";
 
-    /**
-     * Determine the type of the Object for any QCObjects Object
-     *
-     * @param {Object} object
-     */
-    export const __getType__ = function __getType__(o_c:any):any {
-        let _ret_ = "";
-        switch (true) {
-          case __is_raw_class__(o_c) && !!o_c.name:
-            _ret_ = o_c.name;
-            break;
-          case typeof o_c === "object" &&
-            (!!o_c.constructor &&
-              !!o_c.constructor.name)
-            && o_c.constructor.name !== "":
-            _ret_ = o_c.constructor.name;
-            break;
-          case (!!o_c && !!o_c.__classType) && o_c.__classType !== "":
-            _ret_ = o_c.__classType;
-            break;
-          case (!!o_c && !!o_c.__definition) && (!!o_c.__definition.__classType) && o_c.__definition.__classType !== "":
-            _ret_ = o_c.__definition.__classType;
-            break;
-          case typeof o_c === "function" && !!o_c.name:
-            _ret_ = o_c.name;
-            break;
-          default:
-            _ret_ = ObjectName(o_c);
-            break;
-        }
-        return _ret_;
-      };
-  
+/**
+ * Determine the type of the Object for any QCObjects Object
+ *
+ * @param {Object} object
+ */
+export const __getType__ = function __getType__(o_c: any): any {
+  let _ret_ = "";
+  switch (true) {
+    case typeof o_c === "object" &&
+      (!!o_c.constructor &&
+        !!o_c.constructor.name)
+      && o_c.constructor.name !== "":
+      _ret_ = o_c.constructor.name;
+      break;
+    case typeof o_c === "function" && !!o_c.name:
+      _ret_ = o_c.name;
+      break;
+    case __is_raw_class__(o_c) && !!o_c.name:
+      _ret_ = o_c.name;
+      break;
+    case (!!o_c && !!o_c.__classType) && o_c.__classType !== "":
+      _ret_ = o_c.__classType;
+      break;
+    case (!!o_c && !!o_c.__definition) && (!!o_c.__definition.__classType) && o_c.__definition.__classType !== "":
+      _ret_ = o_c.__definition.__classType;
+      break;
+    default:
+      _ret_ = ObjectName(o_c);
+      break;
+  }
+  return _ret_;
+};

package/src/top.ts

@@ -2,6 +2,12 @@ import { IComplexStorageCache, IComponent, IConfigService, IQCObjectsElement } f
 import { buildComponents } from "./ComponentFactory";
 import { _CastProps } from "./Cast";
 import { GlobalSettings } from "./globalSettings";
+import { Class } from "./Class";
+import { ClassFactory } from "./ClassFactory";
+import { Export } from "./Export";
+import { isBrowser } from "./platform";
+import {  _QC_CLASSES, getPackagesNamesList, getPackagesList, getClassesList, getClassesNamesList } from "./PrimaryCollections";
+import { logger } from "./Logger";
 
 type QCObjects = {
     lastCache?:IComplexStorageCache,
@@ -124,3 +130,79 @@ export const get = (name:string, _defaultValue?:any):any => {
 };
 
 resetTop();
+
+const _define_props = function (_top: any) {
+    if (!Object.hasOwn(_top, "PackagesList")) {
+        Object.defineProperty(_top, "PackagesList", {
+          // eslint-disable-next-line no-unused-vars
+          set:(value) => {
+            logger.debug("PackagesList is readonly");
+  
+          },
+          get:():any => {
+            return getPackagesList();
+          }
+        });
+  
+      }
+  
+  
+    if (!Object.hasOwn(_top, "PackagesNameList")) {
+      Object.defineProperty(_top, "PackagesNameList", {
+        // eslint-disable-next-line no-unused-vars
+        set:(val) => {
+          logger.debug("PackagesNameList is readonly");
+
+        },
+        get:():any =>{
+            return getPackagesNamesList();
+        }
+      });
+
+    }
+
+    if (!Object.hasOwn(_top, "ClassesList")) {
+      Object.defineProperty(_top, "ClassesList", {
+        // eslint-disable-next-line no-unused-vars
+        set:(value) => {
+          logger.debug("ClassesList is readonly");
+
+        },
+        get:(): any => {
+            return getClassesList();
+        }
+      });
+    }
+
+    if (!Object.hasOwn(_top, "ClassesNameList")) {
+      Object.defineProperty(_top, "ClassesNameList", {
+        // eslint-disable-next-line no-unused-vars
+        set(value):any {
+          logger.debug("ClassesNameList is readonly");
+
+        },
+        get:(): any => {
+            return getClassesNamesList();
+        }
+      });
+
+    }
+
+
+  };
+
+
+  if (isBrowser) {
+    // use of GLOBAL word is deprecated in node.js
+    // this is only for compatibility purpose with old versions of QCObjects in browsers
+    Class("GLOBAL", (_QC_CLASSES as any).global); // case insensitive for compatibility con old versions;
+    Export(ClassFactory("GLOBAL"));
+  }
+
+  if (isBrowser && typeof window !== "undefined") {
+    set("global", window);
+  } else if (isBrowser && typeof globalThis !== "undefined") {
+    set("global", globalThis);
+  }
+
+  _define_props(_top);