qcobjects 2.4.107-ts → 2.4.108-ts

package/src/CONFIG.ts

@@ -0,0 +1,96 @@
+import { setBasePath } from "./basePath";
+import { _CastProps } from "./Cast";
+import { _Crypt, _CryptObject, _DecryptObject } from "./Crypt";
+import { _DataStringify } from "./DataStringify";
+import { logger } from "./Logger";
+import { GlobalProcessor as Processor } from "./Processor";
+import { _secretKey } from "./secretKey";
+import { Package } from "./Package";
+import { InheritClass } from "./InheritClass";
+import { ICONFIG } from "types";
+import { ConfigSettings } from "./ConfigSettings";
+
+
+export class CONFIG extends InheritClass implements ICONFIG {
+
+  get _CONFIG_ENC(): string {
+    return ConfigSettings.instance._CONFIG_ENC;
+  }
+
+  get _CONFIG(): unknown {
+    return ConfigSettings.instance._CONFIG as unknown;
+  }
+
+  set(name: string, value: unknown) {
+    logger.debug(`CONFIG.set  ${name}: ${value as string}`);
+    // hack to force update basePath from CONFIG
+    if (name === "basePath") {
+      setBasePath(value as string);
+    }
+    let _conf;
+    try {
+      _conf = (
+        function (config): any {
+          if (config._CONFIG_ENC === null) {
+            config._CONFIG_ENC = _Crypt.encrypt(_DataStringify({}), _secretKey);
+          }
+          const _protectedEnc = config._CONFIG_ENC.valueOf();
+          const _protectedConf = config._CONFIG?.valueOf();
+          return _CastProps(_protectedConf, _DecryptObject(_protectedEnc));
+        }
+      )(ConfigSettings.instance);
+    } catch (e) {
+      _conf = {};
+      console.error(e);
+      logger.debug("failed to encrypt config");
+    }
+
+    _conf[name] = value;
+    ConfigSettings.instance._CONFIG_ENC = _CryptObject(_conf);
+    ConfigSettings.instance.set(name, value);
+  }
+
+  get(name: string, _default?: unknown): any {
+    let _value;
+    try {
+      const _conf = (
+        function (config): any {
+          if (config._CONFIG_ENC === null) {
+            config._CONFIG_ENC = _Crypt.encrypt(_DataStringify({}), _secretKey);
+          }
+          const _protectedEnc = config._CONFIG_ENC.valueOf();
+          const _protectedConf = config._CONFIG.valueOf();
+          return _CastProps(_protectedConf, _DecryptObject(_protectedEnc));
+        }
+      )(ConfigSettings.instance);
+      if (typeof _conf[name] !== "undefined") {
+        _value = _conf[name];
+      }
+    } catch (e) {
+      console.error(e);
+      logger.debug("Something wrong when trying to get CONFIG values");
+      logger.debug("No config value for: " + name);
+      _value = _default;
+    }
+    return Processor.processObject(_value) || _default;
+  }
+
+  private static _instance:CONFIG;
+  static get instance ():CONFIG {
+    if (typeof CONFIG._instance === "undefined") {
+      CONFIG._instance = new CONFIG();
+    }
+    return CONFIG._instance;
+  }
+
+  static set(name: string, value: unknown) {
+    (CONFIG.instance.set(name, value));
+  }
+  static get(name: string, value?: unknown): any {
+    return (CONFIG.instance.get(name, value));
+  }
+
+}
+
+
+Package("com.qcobjects", [CONFIG]);

package/src/Cast.ts

@@ -0,0 +1,46 @@
+import { logger } from "./Logger";
+
+/**
+ * Casts an object to another object class type
+ *
+ * @param {Object} obj_source
+ * @param {Object} obj_dest
+ */
+export const _Cast = function (obj_source: any, obj_dest: any):any {
+    for (const v in obj_source) {
+        if (typeof obj_source[v] !== "undefined") {
+            try {
+                obj_dest[v] = obj_source[v];
+            } catch (e:any) {
+                logger.debug(`An error ocurred: ${e}.`);
+                logger.warn(`Unable to cast ${(typeof obj_source).toString()}.${typeof v.toString()} to ${(typeof obj_dest).toString()}.${typeof v.toString()}`);
+            }
+        }
+    }
+    return obj_dest;
+};
+
+/**
+ * Casts an object to another object class type. Only properties
+ *
+ * @param {Object} obj_source
+ * @param {Object} obj_dest
+ */
+export const _CastProps = function (obj_source: any, obj_dest: any):any {
+    for (const v in obj_source) {
+        if (typeof obj_source[v] !== "undefined" && typeof obj_source[v] !== "function") {
+            try {
+                obj_dest[v] = obj_source[v];
+            } catch (e:any) {
+                logger.debug(`An error ocurred: ${e}.`);
+            }
+        } else if (typeof obj_source[v] === "function") {
+            try {
+                obj_dest[v] = obj_source[v].bind(obj_dest);
+            } catch (e:any) {
+                logger.warn(e);
+            }
+        }
+    }
+    return obj_dest;
+};

package/src/Class.ts

@@ -0,0 +1,303 @@
+import { _QC_CLASSES } from "./PrimaryCollections";
+import { _Cast, _CastProps } from "./Cast";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { __getType__ } from "./getType";
+import { __instanceID, IncrementInstanceID } from "./IncrementInstanceID";
+import { _methods_ } from "./introspection";
+import { is_a } from "./is_a";
+import { __is__forbidden_name__ } from "./is_forbidden_name";
+import { _LegacyCopy } from "./LegacyCopy";
+import { logger } from "./Logger";
+import { isBrowser } from "./platform";
+import { IQCObjectsElement, TBody, TClass } from "types";
+import { InheritClass } from "./InheritClass";
+import { _top } from "./top";
+
+/**
+ * Creates new object class  of another object
+ *
+ * @param {String} name
+ * @param {Object} type
+ * @param {Object} definition
+ * 
+ * @example 
+ * Class (name, type, definition)
+ * Class (name, type)
+ * Class (name, definition)
+ * Class ()
+ * 
+ * 
+ * const MyClass = Class ("MyComponent", Component, {
+ *  name: "one_component",
+ *  method1 : () => {console.log ("done") }
+ * })
+ * const myClassInstance = new MyClass ({name: "one_component"})
+ * 
+ * const MyClass = Class ("MyService",{
+ *  name: "myservice",
+ * })
+ * 
+ * const myClassInstance = new MyClass ({name: "myservice"})
+ */
+
+
+
+export const Class: TClass = (name?: string, _type?: unknown, _definition?: unknown): InheritClass => {
+  const _types_ = {};
+  let type: unknown, definition: unknown;
+
+  switch (true) {
+    case !name && !_type && !_definition:
+      return class { } as unknown as InheritClass;
+    case !!name && !_type && !_definition:
+      type = class { };
+      definition = {};
+      break;
+    case !!name && !_type && !!_definition:
+      type = class { };
+      definition = _definition;
+      break;
+    case !!name && !!_type && !!_definition:
+      type = _type;
+      definition = _definition;
+      break;
+    default:
+      return class { } as unknown as InheritClass;
+  }
+  if (typeof name !== "string") {
+    throw new Error("Class name must be a string");
+  }
+
+  if (typeof type !== "function") {
+    throw new Error("Class type must be a function or class");
+  }
+
+  if (__is__forbidden_name__(name)) {
+    throw new Error(`${name} is not an allowed word in the name of a class`);
+  }
+
+  if (typeof (type as any).__definition === "object"
+    && (type as any).__definition
+    && Object.keys((type as any).__definition).length !== 0) {
+    (definition as any).__definition = Object.assign(_LegacyCopy((type as any).__definition,["name"]), type);
+  }
+
+  (_types_ as any)[type.name] = type;
+
+  if (typeof definition === "undefined" || definition === null) {
+    definition = {};
+  } else {
+    definition = { ...definition };
+  }
+
+  /* hack to prevent duplicate __instanceID */
+  if (typeof (definition as any).__instanceID !== "undefined") {
+    delete (definition as any).__instanceID;
+  }
+
+  _QC_CLASSES[name] = class extends (_types_ as any)[type.name] {
+    __instanceID!: number;
+    __namespace?: string | undefined;
+    __definition: any = {
+      ...(definition as any)
+    };
+    childs: any;
+    private _body: TBody;
+    public get body(): TBody {
+      return this._body;
+    }
+    public set body(value: TBody) {
+      this._body = value;
+    }
+
+    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;
+    }
+
+    static getParentClass(): any {
+      return Object.getPrototypeOf(this.prototype.constructor);
+    }
+
+    constructor(_o_?: any) {
+      super(_o_ || {});
+
+      const self = this;
+      IncrementInstanceID();
+      if (!(self as any).__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[self.__classType]).map(function <T>(m: unknown): T {
+        self[(m as Function).name] = (m as Function).bind(self);
+        return m as T;
+      });
+      _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 {
+        if (typeof self.__new__ === "function") {
+          self.__new__.call(self, _o_);
+        } else if (typeof super.__new__ === "function") {
+          self.__new__ = super.__new__.bind(self);
+          self.__new__.call(self, _o_);
+        }
+        if (typeof self === "object" && Object.hasOwn(self, "_new_") && typeof (self._new_ as any).isCalled === "undefined") {
+          try {
+            self._new_(_o_);
+            (self._new_ as any).isCalled = true;
+          } catch (e: any) {
+            logger.warn(`${self.__classType}._new_() failed with error: ${e}`);
+          }
+        }
+      } catch (e: any) {
+        logger.warn(e);
+      }
+    }
+
+    __new__(_o_: any) {
+      _CastProps(_o_, this);
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    _new_(_o_?: any) { }
+
+    getClass(): any {
+      return Object.getPrototypeOf(this.constructor);
+    }
+
+    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");
+      }
+    }
+
+  };
+
+  // remove the keys from definition that exist in the prototype
+
+  _QC_CLASSES[name] = _CastProps(definition, _QC_CLASSES[name]);
+  _QC_CLASSES[name].__definition = definition;
+  _QC_CLASSES[name].__definition.__classType = name;
+  _QC_CLASSES[name].__definition.__new__ = function __new__(_o_: any) {
+    _CastProps(_o_, this);
+  };
+
+  (_top as any)[name] = _QC_CLASSES[name];
+
+  return _QC_CLASSES[name] as InheritClass;
+};
+if (typeof Class.prototype !== "undefined") {
+  Class.prototype.toString = function () {
+    return "Class(name, type, definition) { [QCObjects native code] }";
+  };
+}
+

package/src/ClassFactory.ts

@@ -0,0 +1,34 @@
+/**
+ * Returns the QCObjects Class Factory of a given ClassName
+ *
+ * @param {String} name
+ */
+
+import { __is_raw_class__ } from "./is_raw_class";
+import { _QC_CLASSES, _QC_PACKAGES } from "./PrimaryCollections";
+import { TClassFactory } from "types";
+
+export const ClassFactory:TClassFactory =  (className:string):any => {
+    let _classFactory;
+    if (typeof className === "undefined" || className === null) {
+        throw Error ("You need to pass a parameter {className}");
+    }
+    if (className !== null && className.indexOf(".") > -1) {
+        const packageName = className.split(".").slice(0, className.split(".").length - 1).join(".");
+        const _className = className.split(".").slice(-1).join("");
+        const _package = _QC_PACKAGES[packageName] || [];
+        const packageClasses = _package.filter((classFactory:any) => {
+            return (__is_raw_class__(classFactory));
+        }).reverse();
+        if (packageClasses.length > 0) {
+            _classFactory = packageClasses[0];
+        } else {
+            throw Error(`Class ${_className} not found. Found classes: ${JSON.stringify(packageClasses)} in package ${packageName}`);
+        }
+    } else if (className !== null && Object.hasOwn(_QC_CLASSES, className)) {
+        _classFactory = _QC_CLASSES[className];
+    } else {
+        throw Error(`Unable to determine class ${className}. Unable to retrieve the class factory.`);
+    }
+    return _classFactory;
+};

package/src/ComplexStorageCache.ts

@@ -0,0 +1,97 @@
+import { Base64 } from "./Base64";
+import { _DataStringify } from "./DataStringify";
+import { logger } from "./Logger";
+
+export class ComplexStorageCache {
+
+  constructor(params: { index: any; load: any; alternate: any; }) {
+    let load, alternate;
+    const object = params.index;
+    if (typeof object !== "undefined") {
+      load = params.load;
+      alternate = params.alternate;
+      const cachedObjectID = this.getID(object);
+      const cachedResponse = localStorage.getItem(cachedObjectID as string);
+      if (this.isEmpty(cachedResponse)) {
+        const cachedNewResponse = load.call(null, {
+          cachedObjectID,
+          cachedResponse,
+          "cache": this
+        });
+        this.save(object, cachedNewResponse);
+        logger.debug("RESPONSE OF {{cachedObjectID}} CACHED".replace("{{cachedObjectID}}", cachedObjectID as string));
+      } else {
+        alternate.call(null, {
+          cachedObjectID,
+          cachedResponse,
+          "cache": this
+        });
+        logger.debug("RESPONSE OF {{cachedObjectID}} IS ALREADY CACHED ".replace("{{cachedObjectID}}", cachedObjectID as string));
+      }
+
+    } else {
+      throw new Error("ComplexStorageCache: index is undefined");
+    }
+    return this;
+  }
+
+  getItem(cachedObjectID: string):any {
+    const retrievedObject = localStorage.getItem(cachedObjectID);
+    if (!this.isEmpty(retrievedObject)) {
+      return JSON.parse(retrievedObject as string);
+    } else {
+      return null;
+    }
+  }
+
+
+  setItem(cachedObjectID: string, value: any) {
+    localStorage.setItem(cachedObjectID, _DataStringify(value));
+  }
+
+  isEmpty(object: string | number | null) {
+    let r = false;
+    switch (true) {
+      case (typeof object === "undefined"):
+      case (typeof object === "string" && object === ""):
+      case (typeof object === "string" && object === "undefined"):
+      case (typeof object === "number" && object === 0):
+      case (object === null):
+        r = true;
+        break;
+      default:
+        r = false;
+    }
+    return r;
+  }
+
+
+  getID(object: any) {
+    let cachedObjectID;
+    if (typeof object !== "undefined") {
+      cachedObjectID = "cachedObject_" + Base64.encode(_DataStringify(object).replace(/\{|\}|,/g, "_"));
+    }
+    return cachedObjectID;
+  }
+
+  save(object: any, cachedNewResponse: any) {
+    const cachedObjectID = this.getID(object);
+    logger.debug("CACHING THE RESPONSE OF {{cachedObjectID}} ".replace("{{cachedObjectID}}", cachedObjectID as string));
+    this.setItem(cachedObjectID as string, cachedNewResponse);
+  }
+
+  getCached(object: any):any {
+    const cachedObjectID = this.getID(object);
+    return this.getItem(cachedObjectID as string);
+  }
+
+  clear() {
+    Object.keys(localStorage).filter(function (k) {
+      return k.startsWith("cachedObject_");
+    }).map(function (c):any {
+      localStorage.removeItem(c);
+      return c;
+    });
+  }
+
+}