qcobjects 2.4.107-ts → 2.5.101-ts

package/src/Package.ts

@@ -0,0 +1,67 @@
+import { InheritClass } from "./InheritClass";
+import { __is_raw_class__ } from "./is_raw_class";
+import { _QC_PACKAGES } from "./PrimaryCollections";
+import { __register_class__ } from "./RegisterClass";
+
+/**
+ * Defines a package for Class classification
+ *
+ * @param {Object} namespace
+ * @param {Object} classes
+ */
+export const Package = function (namespace: string, classes: any[] = []): any[] | undefined {
+  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 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;
+    });
+    (_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 => {
+      __register_class__(_class_, namespace);
+      return _class_ as T;
+    });
+  }
+  return ((Object.hasOwn(_QC_PACKAGES, namespace)) ? ((_QC_PACKAGES as any)[namespace]) : (undefined)) as any[] | undefined;
+};
+Package.prototype.toString = function () {
+  return "Package(namespace, classes) { [QCObjects native code] }";
+};

package/src/PrimaryCollections.ts

@@ -0,0 +1,7 @@
+import { T_QC_CLASSES, T_QC_PACKAGES } from "types";
+
+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[] = [];
+

package/src/Processor.ts

@@ -0,0 +1,93 @@
+import {type IComponent, type IProcessor } from "types";
+import { CONFIG } from "./CONFIG";
+import { InheritClass } from "./InheritClass";
+import { New } from "./New";
+import { _top } from "./top";
+import { Component } from "./Component";
+import { Package } from "./Package";
+
+export class Processor extends InheritClass implements IProcessor {
+  protected static _instance:IProcessor | undefined;
+  constructor({ component, processors }: { component: IComponent | null, processors?:any }) {
+    super({ component });
+    if (typeof processors !== "undefined"){
+      this.processors = Object.assign (processors,Processor.instance.processors);
+    }
+  }
+
+  processors:any = {
+    "config"(component: Component, arg: string):string {
+      return CONFIG.get(arg, "") as string;
+    },
+    "ENV"(component: Component, arg: string):string {
+      return (typeof process !== "undefined") ? (process.env[arg] as string) : ("");
+    },
+    "global"(component: Component, arg: string):string {
+      return (typeof _top !== "undefined") ? ((_top as any)[arg] as string) : ("");
+    }
+  };
+
+  static get instance ():IProcessor {
+    if (typeof Processor._instance === "undefined"){
+      Processor._instance = new Processor({component:null});
+    }
+    return Processor._instance;
+  }
+
+  setProcessor(_proc_: Function) {
+    if (typeof _proc_ === "function" && _proc_.name !== "") {
+      this.processors[_proc_.name] = _proc_;
+    }
+  }
+
+  component!: IComponent|null;
+
+
+   execute(component: IComponent, processorName: string, args: string):string {
+    const processorHandler = (typeof component !== "undefined" && component !== null) ? (component.processorHandler) : (this);
+    return processorHandler?.processors[processorName].bind(processorHandler).apply(processorHandler, [component, args?.split(",")]) as string;
+  }
+
+   process(template: string, component: IComponent | null = null) {
+    const processorHandler = (component !== null) ? (component.processorHandler) : (New(Processor, { component: null }));
+    if (typeof template === "string") {
+      Object.keys(processorHandler.processors).map(function (funcName) {
+        [...template.matchAll(new RegExp("\\$" + funcName + "\\((.*)\\).*", "g"))].map(
+          function (procesorMatch) {
+            const match0 = `$${funcName}(${procesorMatch[1]})`;
+            template = template.replace(match0, processorHandler.execute.bind(processorHandler).call(processorHandler, component, funcName, procesorMatch[1]));
+            return procesorMatch;
+          }
+        );
+      });
+    }
+    return template;
+  }
+
+   processObject(obj: any, component: IComponent | null = null):any {
+    let __instance__: IProcessor | undefined = (component === null) ? (this) : (component.processorHandler);
+    if (typeof __instance__ === "undefined") {
+      __instance__ = new Processor({ component });
+    }
+    if (typeof obj === "object") {
+      Object.keys(obj).map(
+         (_k) => {
+          if (typeof obj[_k] === "object" && !Object.hasOwn(obj[_k], "call")) {
+            obj[_k] = __instance__?.processObject.bind(__instance__)(obj[_k], component as IComponent);
+          } else if (typeof obj[_k] === "string") {
+            obj[_k] = __instance__?.process.bind(__instance__)(obj[_k], component as IComponent);
+          }
+          return _k;
+        }
+      );
+    } else if (typeof obj === "string") {
+      obj = __instance__.process.bind(__instance__)(obj, component as IComponent);
+    }
+    return obj;
+  }
+
+}
+
+export const GlobalProcessor:IProcessor = Processor.instance;
+
+Package("com.qcobjects", [Processor]);

package/src/QCObjects.ts

@@ -0,0 +1,100 @@
+/**
+ * QCObjects  2.4
+ * ________________
+ *
+ * Author: Jean Machuca <correojean@gmail.com>
+ *
+ * Cross Browser Javascript Framework for MVC Patterns
+ * QuickCorp/QCObjects is licensed under the
+ * GNU Lesser General Public License v3.0
+ * [LICENSE] (https://github.com/QuickCorp/QCObjects/blob/master/LICENSE.txt)
+ *
+ * Permissions of this copyleft license are conditioned on making available
+ * complete source code of licensed works and modifications under the same
+ * license or the GNU GPLv3. Copyright and license notices must be preserved.
+ * Contributors provide an express grant of patent rights. However, a larger
+ * work using the licensed work through interfaces provided by the licensed
+ * work may be distributed under different terms and without source code for
+ * the larger work.
+ *
+ * Copyright (C) 2015 Jean Machuca,<correojean@gmail.com>
+ *
+ * Everyone is permitted to copy and distribute verbatim copies of this
+ * license document, but changing it is not allowed.
+ */
+/* eslint no-unused-vars: "off" */
+/* eslint no-redeclare: "off" */
+/* eslint no-empty: "off" */
+/* eslint strict: "off" */
+
+/* eslint no-mixed-operators: "off" */
+
+"use strict";
+
+export * as AssignPolyfill from "./assign";
+export { _top, resetTop } from "./top";
+export { _QC_CLASSES, _QC_PACKAGES, _QC_PACKAGES_IMPORTED, _QC_READY_LISTENERS } from "./PrimaryCollections";
+export { _DataStringify } from "./DataStringify";
+export { _DOMCreateElement } from "./DOMCreateElement";
+export { _methods_, _protected_code_ } from "./introspection";
+export { logger, Logger } from "./Logger";
+export { _require_, is_phonegap, isBrowser, isNodeCommonJS } from "./platform";
+export { subelements } from "./subelements";
+export { __is_raw_class__ } from "./is_raw_class";
+export { _LegacyCopy } from "./LegacyCopy";
+export { _fireAsyncLoad, asyncLoad } from "./asyncLoad";
+export { __instanceID } from "./IncrementInstanceID";
+export { ObjectName } from "./ObjectName";
+export { __getType__ } from "./getType";
+export { is_a } from "./is_a";
+export { ComplexStorageCache } from "./ComplexStorageCache";
+export { waitUntil } from "./waitUntil";
+export { _Cast, _CastProps } from "./Cast";
+export { isQCObjects_Class, isQCObjects_Object } from "./isQCObjects";
+export { Package } from "./Package";
+export { ClassFactory } from "./ClassFactory";
+export { Export } from "./Export";
+export { Class } from "./Class";
+export { InheritClass } from "./InheritClass";
+export { _super_ } from "./super";
+export { shortCode } from "./shortCode";
+export { Processor } from "./Processor";
+export { New } from "./New";
+export { _Ready, ready, Ready } from "./Ready";
+export { captureFalseTouch } from "./captureFalseTouch";
+export { serviceLoader } from "./serviceLoader";
+export { componentLoader } from "./componentLoader";
+export { _buildComponentsFromElements_, ComponentURI } from "./ComponentFactory";
+export { NamespaceRef } from "./NamespaceRef";
+export { setDefaultProcessors } from "./defaultProcessors";
+export { Tag, TagElements } from "./Tag";
+export { Import } from "./Import";
+export { BackendMicroservice } from "./BackendMicroservice";
+export { Component } from "./Component";
+export { _Crypt } from "./Crypt";
+export { DefaultTemplateHandler } from "./DefaultTemplateHandler";
+export { SourceJS } from "./SourceJS";
+export { SourceCSS } from "./SourceCSS";
+export { GlobalSettings } from "./globalSettings";
+export { RegisterClass } from "./RegisterClass";
+export { _ComponentWidget_, RegisterWidget, RegisterWidgets } from "./WidgetsFactory";
+export { CONFIG } from "./CONFIG";
+export { Controller } from "./Controller";
+export { View } from "./View";
+export { ConfigService, JSONService, Service } from "./Service";
+export { VO } from "./VO";
+export { Effect } from "./Effect";
+export { TransitionEffect } from "./TransitionEffect";
+export { Timer } from "./Timer";
+export { _tag_filter_ } from "./tag_filter";
+export { range } from "./range";
+export { ArrayCollection, ArrayList } from "./ArrayCollection";
+export { DDO } from "./DDO";
+export { Toggle } from "./Toggle";
+export { findPackageNodePath } from "./findPackageNodePath";
+export { getDocumentLayout } from "./DocumentLayout";
+export { IQCObjectsElement, IQCObjectsShadowedElement } from "types";
+export { __to_number } from "./mathFunctions";
+export {_top as global} from "./top";
+export {__make_global__} from "./make_global";
+export * as QCObjects from "./MainProcess";

package/src/Ready.ts

@@ -0,0 +1,44 @@
+import { CONFIG } from "./CONFIG";
+import { isBrowser } from "./platform";
+import { _QC_READY_LISTENERS } from "./PrimaryCollections";
+import { _top } from "./top";
+
+/**
+ * Defines a Custom Ready listener
+ */
+export const Ready = function Ready(e:any) {
+    if (isBrowser) {
+        _QC_READY_LISTENERS.push(e.bind(window) as never);
+    } else if (typeof global !== "undefined") {
+        _QC_READY_LISTENERS.push(e.bind(global) as never);
+    }
+};
+
+export const ready = Ready; // case insensitive ready option
+
+/**
+ * Default Ready event function for window. Executes all micro ready events of Import calls
+ *
+ * @param {Object} e
+ */
+// eslint-disable-next-line no-unused-vars
+export const _Ready = function (e:any) {
+    const _execReady = function () {
+        // eslint-disable-next-line array-callback-return
+        _QC_READY_LISTENERS.map(function (_ready_listener_, _r):any {
+            if (typeof _ready_listener_ === "function") {
+                (_ready_listener_ as Function)();
+                _QC_READY_LISTENERS.splice(_r, 1);
+            }
+        });
+    };
+    if (CONFIG.get("delayForReady") > 0) {
+        if (isBrowser) {
+            setTimeout(_execReady.bind(window), CONFIG.get("delayForReady"));
+        } else if (typeof global !== "undefined") {
+            setTimeout(_execReady.bind(global), CONFIG.get("delayForReady"));
+        }
+    } else {
+        _execReady.call(_top);
+    }
+};

package/src/RegisterClass.ts

@@ -0,0 +1,26 @@
+import { __getType__ } from "./getType";
+import { __make_global__ } from "./make_global";
+import { _QC_CLASSES } 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);
+};
+__make_global__(RegisterClass);

package/src/Service.ts

@@ -0,0 +1,127 @@
+import { _basePath_ } from "./basePath";
+import { _Crypt } from "./Crypt";
+import { _domain_ } from "./domain";
+import { InheritClass } from "./InheritClass";
+import { logger } from "./Logger";
+import { Package } from "./Package";
+import { _secretKey } from "./secretKey";
+import { CONFIG } from "./CONFIG";
+import { IJSONService, IService, TServiceDoneResponse, TServiceStandardResponse } from "types";
+
+export class Service extends InheritClass implements IService{
+    options!: object;
+    withCredentials!: boolean;
+    useHTTP2: any;
+    // eslint-disable-next-line no-unused-vars
+    mockup({ request, service }: TServiceStandardResponse): void {
+        throw new Error("Method not implemented.");
+    }
+    name!: string;
+    responseHeaders: any;
+    // eslint-disable-next-line no-unused-vars
+    local({ request, service }: TServiceStandardResponse): void {
+        throw new Error("Method not implemented.");
+    }
+    kind = "rest";
+    /* it can be rest, mockup, local */
+    domain = _domain_;
+    basePath = _basePath_;
+    url = "";
+    method = "GET";
+    data = {};
+    reload = false;
+    cached = false;
+
+    headers: any;
+    template: unknown;
+    
+    // eslint-disable-next-line no-unused-vars
+    done({ request, service }: TServiceDoneResponse): void {
+        throw new Error("Method not implemented.");
+    }
+    // eslint-disable-next-line no-unused-vars
+    fail(...args: any[]): void {
+        throw new Error("Method not implemented.");
+    }
+
+    set(name:string, value:never) {
+        this[name] = value;
+    }
+
+    get(name:string, _default?:never) {
+        return this[name] as never || _default;
+    }
+
+}
+
+export class JSONService extends Service implements IJSONService{
+    method = "GET";
+    cached = false;
+    headers = {
+        "Content-Type": "application/json",
+        "charset": "utf-8"
+    };
+
+    JSONresponse?:JSON = undefined;
+    done(result:TServiceDoneResponse) {
+        logger.debug("***** RECEIVED RESPONSE:");
+        logger.debug(result.service.template as string);
+        this.JSONresponse = JSON.parse(result.service.template as string);
+    }
+
+
+
+}
+
+export class ConfigService extends JSONService {
+    method = "GET";
+    cached = false;
+    configFileName = "config.json";
+    headers = {
+        "Content-Type": "application/json",
+        "charset": "utf-8"
+    };
+
+    configLoaded():Promise<void>{
+        throw Error ("Method not implemented.");
+    }
+
+    JSONresponse?:JSON = undefined;
+    done(result:TServiceDoneResponse) {
+        logger.debug("***** CONFIG LOADED:");
+        logger.debug(result.service.template as string);
+        this.JSONresponse = JSON.parse(result.service.template as string);
+        if (Object.hasOwn(this.JSONresponse as object, "__encoded__")) {
+            const decodedValue:string = _Crypt.decrypt((this.JSONresponse as any)?.__encoded__, _secretKey);
+            this.JSONresponse = JSON.parse(decodedValue);
+        }
+        const jsonResponse:any = this.JSONresponse;
+        Object.keys(jsonResponse as object).map((k:string) => {
+            CONFIG.set(k, (jsonResponse as never)[k]);
+            return k;
+        });
+        this.configLoaded().catch((e:any)=>{throw new Error (`An error ocurred: ${e}`);});
+    }
+
+    fail() {
+        this.configLoaded().catch((e:any)=>{throw new Error (`An error ocurred: ${e}`);});
+    }
+
+    constructor() {
+        super();
+        this.set("url", `${this.get("basePath") as string}${this.get("configFileName") as string}` as never);
+    }
+}
+
+
+Package("com.qcobjects.api", [
+    Service
+]);
+
+Package("com.qcobjects.api.services", [
+    JSONService
+]);
+
+Package("com.qcobjects.api.config", [
+    ConfigService
+]);

package/src/SourceCSS.ts

@@ -0,0 +1,59 @@
+import { ISourceCSS, TBody } from "types";
+import { _basePath_ } from "./basePath";
+import { _Cast } from "./Cast";
+import { _domain_ } from "./domain";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { InheritClass } from "./InheritClass";
+import { isBrowser } from "./platform";
+import { Package } from "./Package";
+
+export class SourceCSS extends InheritClass implements ISourceCSS  {
+    domain= _domain_;
+    basePath= _basePath_;
+    url= "";
+    data= {};
+    async= false;
+    external= false;
+
+    constructor(o:any){
+      super(o);
+      this.body = _DOMCreateElement("link") as TBody;
+    }
+  fail(): void {
+    throw new Error("Method not implemented.");
+  }
+  Cast(o: any):any {
+    return _Cast(this, o);
+  }
+    set(name:string, value:any) {
+      this[name] = value;
+    }
+    get(name:string, _default?:any):any {
+      return this[name] || _default;
+    }
+    done() { }
+    rebuild() {
+      const context = this;
+      if (isBrowser) {
+        window.document.getElementsByTagName("head")[0].appendChild(
+          (function (s:any, url:string, context:any):any {
+            s.type = "text/css";
+            s.rel = "stylesheet";
+            s.href = url;
+            s.crossOrigin = "anonymous";
+            s.onreadystatechange = function () {
+              if (this.readyState === "complete") {
+                context.done.call(context);
+              }
+            };
+            s.onload = context.done;
+            context.body = s;
+            return s;
+          }).call(this,
+            _DOMCreateElement("link"),
+            (this.external) ? (this.url) : (this.basePath + this.url), context));
+      }
+    }
+  }
+
+  Package("com.qcobjects", [SourceCSS]);

package/src/SourceJS.ts

@@ -0,0 +1,76 @@
+import { ISourceJS } from "types";
+import { _basePath_ } from "./basePath";
+import { _Cast } from "./Cast";
+import { _domain_ } from "./domain";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+import { logger } from "./Logger";
+
+export class SourceJS extends InheritClass implements ISourceJS {
+    domain= _domain_;
+    basePath= _basePath_;
+    type= "text/javascript";
+    containerTag= "body";
+    url= "";
+    data= {};
+    async= false;
+    external= false;
+
+    constructor(o:any){
+      super(o);
+      this.body= _DOMCreateElement("script");
+
+    }
+    set(name:string, value:any) {
+      this[name] = value;
+    }
+    get(name:string, _default?:any):any {
+      return this[name] || _default;
+    }
+    status= false;
+    done() { }
+    fail() { }
+    rebuild() {
+      const context = this;
+      try {
+        document.getElementsByTagName(context.containerTag)[0].appendChild(
+          (function (s:any, url:string, context:any):any {
+            s.type = context.type;
+            s.src = url;
+            s.crossOrigin = (Object.hasOwn(context, "crossOrigin")) ? (context.crossOrigin) : ("anonymous");
+            s.async = context.async;
+            s.onreadystatechange = function () {
+              if (this.readyState === "complete") {
+                context.done.call(context);
+              }
+            };
+            s.onload = function (e:any) {
+              context.status = true;
+              context.done.call(context, e);
+            };
+            s.onerror = function (e:any) {
+              context.status = false;
+              context.fail.call(context, e);
+            };
+            context.body = s;
+            return s;
+          }).call(this,
+            _DOMCreateElement("script"),
+            (this.external) ? (this.url) : (this.basePath + this.url), context));
+      } catch (e:any) {
+        context.status = false;
+        logger.debug(`An error ocurred: ${e}`);
+        context.fail();
+      }
+    }
+    Cast(o:any):any {
+      return _Cast(this, o);
+    }
+    _new_(properties:any) {
+      this.__new__(properties);
+      this.rebuild();
+    }
+  }
+
+  Package("com.qcobjects", [SourceJS]);

package/src/Tag.ts

@@ -0,0 +1,76 @@
+import { IQCObjectsElement, ITagElements } from "types";
+import { ClassFactory } from "./ClassFactory";
+import { New } from "./New";
+import { Package } from "./Package";
+import { isBrowser } from "./platform";
+import { Effect } from "./Effect";
+import { ArrayList } from "./ArrayCollection";
+
+export class TagElements extends ArrayList implements ITagElements {
+    show() {
+      this.map(function (element:any) {
+        return element.style.opacity = 1;
+      });
+    }
+    hide() {
+      this.map(function (element:any) {
+        return element.style.opacity = 0;
+      });
+    }
+    effect<T>(...args:T[]) {
+      const effectArguments = [...args].slice(1);
+      const effectClassName = args[0] as string;
+      let effectClass = undefined;
+      if ((typeof effectClassName).toLowerCase() === "string") {
+        effectClass = ClassFactory(effectClassName);
+      }
+      this.map(function <T>(element:any):T {
+        return ((effectClass as Effect).apply as Function).apply(effectClass, [element].concat(effectArguments)) as T;
+      });
+    }
+    findElements(elementName:any):any {
+      const _o = New(ClassFactory("TagElements"));
+      if (isBrowser) {
+        for (const _k in this) {
+          if (typeof _k === "number" && typeof this[_k] !== "function" && Object.hasOwn(this[_k], "subelements")) {
+            _o.push(this[_k].subelements(elementName));
+          }
+        }
+      } else {
+        // not yet implemented.
+      }
+      return _o;
+    }
+  }
+
+  /**
+   * Gets the element of DOM found by tag name
+   *
+   * @param {Object} tagname
+   * @param {Object} innerHTML
+   */
+  export const Tag = function <T>(tagname:string, innerHTML?:string): T[] {
+    const _o = New(TagElements);
+    if (isBrowser) {
+      const o = (document as unknown as IQCObjectsElement).subelements(tagname);
+      const addedKeys = [];
+      for (let _i = 0; _i < o.length; _i++) {
+        if (typeof innerHTML !== "undefined" && Object.hasOwn(o[_i], "innerHTML")) {
+          o[_i].innerHTML = innerHTML;
+        }
+        if (addedKeys.indexOf(_i) < 0) {
+          _o.push(o[_i]);
+          addedKeys.push(_i);
+        }
+      }
+    } else {
+      // not yet implemented.
+    }
+    return _o as T[];
+  };
+
+
+  Package("com.qcobjects",[
+    TagElements,
+    Tag
+  ]);