qcobjects 2.4.107-ts → 2.5.101-ts

package/src/ComponentFactory.ts

@@ -0,0 +1,122 @@
+import { IQCObjectsElement, TComponentURIParams } from "types";
+import { Class } from "./Class";
+import { ClassFactory } from "./ClassFactory";
+import { Component } from "./Component";
+import { CONFIG } from "./CONFIG";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { __getType__ } from "./getType";
+import { logger } from "./Logger";
+import { New } from "./New";
+import { Package } from "./Package";
+import { isBrowser } from "./platform";
+import { _tag_filter_ } from "./tag_filter";
+
+/**
+ * Returns a standarized uri for a component
+ * @example
+ * templateURI = ComponentURI({'COMPONENTS_BASE_PATH':'','COMPONENT_NAME':'','TPLEXTENSION':'','TPL_SOURCE':''})
+ * @author: Jean Machuca <correojean@gmail.com>
+ * @param params an object with the params to build the uri path
+ */
+export const ComponentURI = ({ TPL_SOURCE, COMPONENTS_BASE_PATH, COMPONENT_NAME, TPLEXTENSION }:TComponentURIParams) => {
+    const templateURI = (TPL_SOURCE === "default") ? (`${COMPONENTS_BASE_PATH}${COMPONENT_NAME}.${TPLEXTENSION}`) : ("");
+    return templateURI;
+};
+
+export const _buildComponentFromElement_ = function (element: Element, __parent__: any) {
+    const __shadowed_not_set = (element.getAttribute("shadowed") === null);
+    const __tplsource_attr_not_set = (element.getAttribute("template-source") === null);
+    const shadowed = (element.getAttribute("shadowed") === "true");
+    const __cached_not_set = (element.getAttribute("cached") === null);
+    const cached = (element.getAttribute("cached") === "true");
+    let tplextension = (typeof CONFIG.get("tplextension") !== "undefined") ? (CONFIG.get("tplextension")) : ("html");
+    tplextension = (element.getAttribute("tplextension") !== null) ? (element.getAttribute("tplextension")) : (tplextension);
+    let _componentName = element.getAttribute("name");
+    const _componentClassName = (element.getAttribute("componentClass") !== null) ? (element.getAttribute("componentClass")) : ("Component");
+    const __componentClassName = (CONFIG.get("preserveComponentBodyTag")) ? (
+        (_componentName !== null) ? ("com.qcobjects.components." + _componentName + ".ComponentBody") : ("com.qcobjects.components.ComponentBody")
+    ) : (_componentClassName);
+    _componentName = (_componentName !== null) ? (_componentName) : (
+        (ClassFactory(__componentClassName as string) &&
+            typeof (ClassFactory(__componentClassName as string) as unknown as typeof Component).name !== "undefined"
+        ) ? (
+            (ClassFactory(__componentClassName as string) as unknown as Component).name
+        ) : ("")
+    );
+    const __classDefinition = ClassFactory(__componentClassName as string) as Component;
+    const __tplsource_prop_set = !!((__componentClassName !== "Component" && ((typeof __classDefinition !== "undefined" && typeof __classDefinition.tplsource === "string") && __classDefinition.tplsource !== "")));
+    const tplsource = (__tplsource_attr_not_set && __tplsource_prop_set) ? (__classDefinition.tplsource) : ((__tplsource_attr_not_set) ? ("default") : (element.getAttribute("template-source")));
+    logger.debug(`template source for  ${_componentName} is ${tplsource} `);
+    logger.debug(`type for ${_componentName} is ${__getType__(__classDefinition)} `);
+
+    const componentURI: string = ComponentURI({
+        "COMPONENTS_BASE_PATH": CONFIG.get("componentsBasePath"),
+        "COMPONENT_NAME": _componentName ,
+        "TPLEXTENSION": tplextension,
+        "TPL_SOURCE": tplsource as string
+    });
+    if (CONFIG.get("preserveComponentBodyTag")) {
+        Package((_componentName !== "") ? ("com.qcobjects.components." + _componentName + "") : ("com.qcobjects.components"), [
+            Class("ComponentBody", Component, {
+                name: _componentName,
+                tplsource,
+                tplextension,
+                reload: true
+            })
+        ]);
+    }
+
+    const __create_component_instance_ = function ():Component {
+        const __shadowed = (__shadowed_not_set) ? ((__classDefinition && __classDefinition.shadowed) || Component.shadowed) : (shadowed);
+        const __definition = {
+            __parent__,
+            name: _componentName,
+            cached: (__cached_not_set) ? (Component.cached) : (cached),
+            shadowed: __shadowed,
+            tplextension,
+            body: (CONFIG.get("preserveComponentBodyTag")) ? (_DOMCreateElement("componentBody")) : (element),
+            templateURI: componentURI,
+            tplsource
+        };
+        if (typeof _componentName === "undefined" || _componentName === "" || _componentName === null) {
+            /* this allows to use the original property defined
+            in the component definition if it is not present in the tag */
+            delete (__definition as any).name;
+        }
+        if (componentURI === "") {
+            /* this allows to use the original property defined
+            in the component definition if it is not present in the tag */
+            delete (__definition as any).templateURI;
+        }
+        const newComponent = New(__classDefinition, __definition) as Component;
+
+        if (CONFIG.get("preserveComponentBodyTag")) {
+            if (typeof newComponent !== "undefined") {
+                element.append(newComponent.body as string | Node);
+            }
+        }
+        return newComponent;
+    };
+    const newComponent = __create_component_instance_();
+    return newComponent;
+};
+
+export const _buildComponentsFromElements_ = function (elements: HTMLElement[], __parent__: Component | null) {
+    let componentsBuiltWith:Component[] = [];
+    if (isBrowser) {
+        componentsBuiltWith = elements.map(
+            function (element: any) {
+                return _buildComponentFromElement_(element, __parent__);
+            }
+        );
+    } else {
+        logger.debug("[_buildComponentsFromElements_] not implemented for Non-Browser environments");
+    }
+    return componentsBuiltWith;
+};
+
+export const buildComponents = (element:HTMLElement):Component[] => {
+    const tagFilter = _tag_filter_;
+    const elements = (element as unknown as IQCObjectsElement).subelements(tagFilter) as HTMLElement[];
+    return _buildComponentsFromElements_(elements, null);
+};

package/src/ConfigSettings.ts

@@ -0,0 +1,62 @@
+import { _basePath_ } from "./basePath";
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+
+type TConfigSettings = {
+  [key: string]: any,
+  relativeImportPath:string,
+  remoteImportsPath:string,
+  remoteSDKPath:string,
+  asynchronousImportsLoad:boolean,
+  removePackageScriptAfterLoading:boolean,
+  componentsBasePath:string,
+  delayForReady:number,
+  preserveComponentBodyTag:false,
+  useConfigService:false,
+  routingWay:string,
+  useSDK:boolean,
+  useLocalSDK:boolean,
+  basePath:string
+};
+
+
+export class ConfigSettings extends InheritClass {
+  public _CONFIG: TConfigSettings = {
+    "relativeImportPath": "",
+    "remoteImportsPath": "",
+    "remoteSDKPath": "https://sdk.qcobjects.dev/",
+    "asynchronousImportsLoad": false,
+    "removePackageScriptAfterLoading": true,
+    "componentsBasePath": "",
+    "delayForReady": 0,
+    "preserveComponentBodyTag": false,
+    "useConfigService": false,
+    "routingWay": "hash",
+    "useSDK": true,
+    "useLocalSDK": false,
+    "basePath": _basePath_
+  };
+  protected static _instance: ConfigSettings;
+  public _CONFIG_ENC = "";
+
+  set(name:string, value:any):void {
+    this._CONFIG[name] = value;
+  }
+
+  get(name:string, _defaultValue?:any):any {
+    return this._CONFIG[name] || _defaultValue;
+  }
+
+  static get instance():ConfigSettings {
+
+    if (typeof ConfigSettings._instance === "undefined") {
+      ConfigSettings._instance = new ConfigSettings();
+    }
+
+    return ConfigSettings._instance;
+  }
+
+
+}
+
+Package("com.qcobjects", [ConfigSettings]);

package/src/Controller.ts

@@ -0,0 +1,90 @@
+import { IController, IComponent, TControllerParams, IQCObjectsElement, IQCObjectsShadowedElement } from "types";
+import { ClassFactory } from "./ClassFactory";
+import { __getType__ } from "./getType";
+import { InheritClass } from "./InheritClass";
+import { logger } from "./Logger";
+import { New } from "./New";
+import { Package } from "./Package";
+import { isBrowser } from "./platform";
+
+export class Controller extends InheritClass implements IController{
+
+  component!: IComponent ;
+  dependencies?: any[] = [];
+  constructor({
+    component,
+    dependencies
+  }: TControllerParams) {
+    super({ component, dependencies });
+    this.component = component;
+    this.dependencies = dependencies;
+    if (typeof this.component === "undefined" || this.component === null) {
+      throw Error(`${__getType__(this)} must be called with a component`);
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  fail?(...args: [...args: any[]]  ): void {
+    throw new Error("Method not implemented.");
+  }
+
+
+  routingSelectedAttr(attrName: string):any {
+    return this.component?.routingSelected.map( (r: any):any => {
+      return r[attrName];
+    }).filter(function (v: any) {
+      return v;
+    }).pop();
+  }
+
+  isTouchable() {
+    return ("ontouchstart" in window) ||
+      ((navigator as any).MaxTouchPoints > 0) ||
+      ((navigator as any).msMaxTouchPoints > 0);
+  }
+
+  onpress(subelementSelector: string, handler: Function) {
+    if (isBrowser){
+      try {
+        if (this.isTouchable()) {
+          ((this.component?.componentRoot as IQCObjectsElement| IQCObjectsShadowedElement)?.subelements(subelementSelector) as any[])[0].addEventListener("touchstart", handler, {
+            passive: true
+          });
+        } else {
+          ((this.component?.componentRoot as IQCObjectsElement | IQCObjectsShadowedElement)?.subelements(subelementSelector) as any[])[0].addEventListener("click", handler, {
+            passive: true
+          });
+        }
+      } catch (e:any) {
+        logger.debug(`An error ocurred: ${e}.`);
+        logger.debug("No button to assign press event");
+      }
+  
+    }
+  }
+
+  createRoutingController() {
+    const controller = this;
+    const component = controller.component;
+    const controllerName = controller.routingSelectedAttr("controllerclass");
+    if (typeof controllerName !== "undefined") {
+      const _Controller = ClassFactory(controllerName) as unknown as IController;
+      if (typeof _Controller !== "undefined" && component !== null) {
+        component.routingController = New(_Controller, {
+          component
+        }) as IController; // Initializes the main controller for the component
+        if (typeof component.routingController !== "undefined" 
+          &&  Object.hasOwn(component.routingController, "done") 
+          && typeof component.routingController.done === "function") {
+          component.routingController.done.call(component.routingController);
+        }
+      }
+    }
+  }
+
+  done() { }
+}
+
+Package("com.qcobjects.controllers", [
+  Controller
+]);

package/src/Crypt.ts

@@ -0,0 +1,87 @@
+import { _ICrypt } from "types";
+import { Base64 } from "./Base64";
+import { _DataStringify } from "./DataStringify";
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+import { _secretKey } from "./secretKey";
+
+
+export class _Crypt extends InheritClass implements _ICrypt{
+    string: string = "";
+    key: string = "";
+    // eslint-disable-next-line no-unused-vars
+    encrypt(_string_: string, key: string): string {
+        throw new Error("Method not implemented.");
+    }
+    // eslint-disable-next-line no-unused-vars
+    decrypt(_string_: string, key: string): string {
+        throw new Error("Method not implemented.");
+    }
+    last_string= "";
+    last_key= "";
+    construct= false;
+    _new_(o: { string?: string; key: string; }) {
+        const string = o.string;
+        let key:string = (Object.hasOwn(o, "key")) ? (o.key) : ("");
+        this.__new__(o);
+        key = (key === "") ? (this.__instanceID.toString()) : (key);
+        this.last_key = key;
+        this.last_string = string as string;
+        this.construct = true;
+    }
+    _encrypt():string {
+        const string = this.string;
+        const key = this.key;
+        let result = "";
+        let char;
+        let keychar;
+        for (let i = 0; i < string.length; i++) {
+            char = string.substr(i, 1);
+            keychar = key.substr((i % key.length) - 1, 1);
+            char = String.fromCharCode(char.charCodeAt(0) + keychar.charCodeAt(0));
+            result += char;
+        }
+        this.last_string = Base64.encode(result);
+        return this.last_string;
+    }
+    _decrypt():string {
+        let string = this.string;
+        const key = this.key;
+        let result = "";
+        let char;
+        let keychar;
+        string = Base64.decode(string);
+        for (let i = 0; i < string.length; i++) {
+            char = string.substr(i, 1);
+            keychar = key.substr((i % key.length) - 1, 1);
+            char = String.fromCharCode(char.charCodeAt(0) - keychar.charCodeAt(0));
+            result += char;
+        }
+
+        this.last_string = result;
+        return this.last_string;
+    } 
+    static encrypt(string:string, key:string):string {
+        const crypt = new _Crypt({
+            string,
+            key: (key !== "") ? (key) : ("12345678ABC")
+        });
+        return crypt._encrypt();
+    } 
+    static decrypt(string:string, key:string) {
+        const crypt = new _Crypt({
+            string,
+            key: (key !== "") ? (key) : ("12345678ABC")
+        });
+        return crypt._decrypt();
+    }
+}
+
+export const _CryptObject = function (o:any):string {
+    return _Crypt.encrypt(_DataStringify(o), _secretKey);
+};
+export const _DecryptObject = function (s:string):any {
+    return (s === "") ? ({}) : (JSON.parse(_Crypt.decrypt(s, _secretKey)));
+};
+
+Package( "com.qcobjects", [_Crypt]);

package/src/DDO.ts

@@ -0,0 +1,93 @@
+import { TDDOParams } from "types";
+import { Export } from "./Export";
+import { InheritClass } from "./InheritClass";
+import { logger } from "./Logger";
+import { ObjectName } from "./ObjectName";
+
+/**
+ * Dynamic Data Objects Class
+ * Usage:
+ * Class('TestDDO',{
+ *    data: {},
+ *    _new_ (){
+ *        this.ddo = New(DDO,{
+ *            instance:this,
+ *            name:'data',
+ *            value:{},
+ *            fget (value){
+ *                logger.debug('returned value '+ value );
+ *            }
+ *            })
+ *    }
+ * });
+ *
+ */
+export class DDO extends InheritClass {
+    constructor({
+        instance,
+        name,
+        fget,
+        fset,
+        value
+    }:TDDOParams) {
+        super({
+            instance,
+            name,
+            fget,
+            fset,
+            value
+        });
+        this._new_({
+            instance,
+            name,
+            fget,
+            fset,
+            value
+        });
+
+    }
+
+    _new_({
+        instance,
+        name,
+        fget,
+        fset
+    }:TDDOParams) {
+        const ddoInstance = this;
+        var name = (typeof name === "undefined") ? (ObjectName(ddoInstance)) : (name);
+
+        Object.defineProperty(instance, name, {
+            set(val) {
+                const _value = val;
+                logger.debug("value changed " + name);
+                let ret;
+                if (typeof fset !== "undefined" && typeof fset === "function") {
+                    ret = fset(_value);
+                } else {
+                    ret = _value;
+                }
+                instance["_" + name] = ret;
+                
+            },
+            get():any {
+                const _value = instance["_" + name];
+                logger.debug("returning value " + name);
+                const is_ddo =  (v:any):any => {
+                    if (typeof v === "object" && Object.hasOwn(v, "value")) {
+                        return v.value;
+                    }
+                    return v;
+                };
+                let ret;
+                if (typeof fget !== "undefined" && typeof fget === "function") {
+                    ret = fget(is_ddo(_value));
+                } else {
+                    ret = is_ddo(_value);
+                }
+                return ret;
+            }
+        });
+    }
+
+}
+Export(DDO);

package/src/DOMCreateElement.ts

@@ -0,0 +1,12 @@
+import { IQCObjectsElement } from "types";
+import { isBrowser } from "./platform";
+
+export const _DOMCreateElement = function (elementName:string):IQCObjectsElement {
+    let _ret_;
+    if (isBrowser) {
+      _ret_ = document.createElement(elementName) as unknown as IQCObjectsElement;
+    } else {
+      _ret_ = {} as IQCObjectsElement;
+    }
+    return _ret_;
+  };

package/src/DataStringify.ts

@@ -0,0 +1,19 @@
+import { _LegacyCopy } from "./LegacyCopy";
+
+export const _DataStringify = function (data:any) {
+    const getCircularReplacer = function () {
+      const seen = new WeakSet();
+      let _level = 0;
+      return function (key:string, value:any):any {
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            _level += 1;
+            return (_level <= 3) ? (_LegacyCopy(value)) : (null);
+          }
+          seen.add(value);
+        }
+        return value;
+      };
+    };
+    return JSON.stringify(data, getCircularReplacer());
+  };

package/src/DefaultTemplateHandler.ts

@@ -0,0 +1,55 @@
+import { DefaultTemplateHandlerParams } from "types";
+import { logger } from "./Logger";
+import { GlobalProcessor as Processor } from "./Processor";
+import { RegisterClass } from "./RegisterClass";
+
+export class DefaultTemplateHandler {
+    template = "";
+    __definition = {};
+    static __definition = {};
+    component;
+
+    constructor({ component, template }:DefaultTemplateHandlerParams) {
+      this.component = component;
+      this.template = template;
+    }
+
+    assign(data:any) {
+      const templateInstance = this;
+      if (typeof templateInstance.component === "undefined") {
+        throw new Error("DefaultTemplateHandler.assign: component is undefined");
+      }
+      if (typeof templateInstance.component.processorHandler === "undefined") {
+        throw new Error("DefaultTemplateHandler.assign: component.processorHandler is undefined");
+      }
+      const processorHandler = templateInstance.component.processorHandler;
+      processorHandler.component = templateInstance.component;
+      let parsedAssignmentText = (typeof templateInstance.template !== "undefined") ? (templateInstance.template) : ("");
+      if (typeof data === "object") {
+        [...Object.keys(data)].map( (k):any => {
+          let _value = data[k];
+          if (typeof _value === "string" || typeof _value === "number" || (!isNaN(_value))) {
+            try {
+              _value = Processor.processObject.bind(processorHandler).call(processorHandler, _value, templateInstance.component);
+              parsedAssignmentText = parsedAssignmentText.replace((new RegExp(`{{${k}}}`, "g")), _value);
+            } catch (e:any) {
+              logger.warn(`${templateInstance.component.name} could not parse processors.`);
+              throw Error(`${templateInstance.component.name} could not parse processors. Reason: ${e.message}`);
+            }
+          }
+          return k;
+        });
+      } else {
+        logger.debug(`${templateInstance.component.name}.data is not an object`);
+      }
+      try {
+        parsedAssignmentText = Processor.processObject.call(processorHandler, parsedAssignmentText, templateInstance.component);
+      } catch (e:any) {
+        logger.warn(`${templateInstance.component.name} could not parse processors.`);
+        throw Error(`${templateInstance.component.name} could not parse processors. Reason: ${e.message}`);
+      }
+      return parsedAssignmentText;
+    }
+
+  }
+  RegisterClass(DefaultTemplateHandler, "com.qcobjects");

package/src/DocumentLayout.ts

@@ -0,0 +1,16 @@
+export const getDocumentLayout = function ():string|undefined {
+    const h = (w:number, h:number) => {
+      return w > h ? "landscape" : null;
+    };
+    const v = (w:number, h:number) => {
+      return h > w ? "portrait" : null;
+    };
+    const square = (w:number, h:number) => {
+      return w === h ? "square" : null;
+    };
+    return [
+      h(document.documentElement.clientWidth, document.documentElement.clientHeight),
+      v(document.documentElement.clientWidth, document.documentElement.clientHeight),
+      square(document.documentElement.clientWidth, document.documentElement.clientHeight)
+    ].filter(e => e !== null).pop();
+  };

package/src/Effect.ts

@@ -0,0 +1,56 @@
+import { IEffect, TEffectParams } from "types";
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+
+export class Effect extends InheritClass implements IEffect{
+  // eslint-disable-next-line no-unused-vars
+  done (...args: any[]): any {
+    throw new Error("Method not implemented.");
+  };
+  // eslint-disable-next-line no-unused-vars
+  apply(...args: any[]) {
+    throw new Error("Method not implemented.");
+  }
+  duration = 1000;
+
+
+  animate({
+    timing,
+    draw,
+    duration
+  }: TEffectParams) {
+    const _self: this = this;
+
+    const start = performance.now();
+
+    requestAnimationFrame(function animate(time) {
+      // timeFraction goes from 0 to 1
+      let timeFraction = (time - start) / duration;
+      if (timeFraction > 1) timeFraction = 1;
+
+      // calculate the current animation state
+      const progress = timing(timeFraction);
+
+      draw(Math.round(progress * 100)); // draw it
+
+      if (timeFraction < 1) {
+        requestAnimationFrame(animate);
+      } else {
+        // if this is an object with a done method
+        if (typeof _self !== "undefined" &&
+          _self !== null &&
+          Object.hasOwn(_self, "done") &&
+          (typeof _self.done).toLowerCase() === "function") {
+          _self.done.call(_self);
+        }
+      }
+
+    });
+  }
+
+}
+
+
+Package("com.qcobjects.effects.base", [
+  Effect
+]);

package/src/Export.ts

@@ -0,0 +1,8 @@
+import { __make_global__ } from "./make_global";
+
+export const Export = function (f:any) {
+    return __make_global__(f);
+  };
+  Export.prototype.toString = function () {
+    return "Export(function or symbol) { [QCObjects native code] }";
+  };