qcobjects 2.4.107-ts → 2.4.108-ts

package/src/Timer.ts

@@ -0,0 +1,42 @@
+import { ITimer, TTimerParams } from "types";
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+
+export class Timer extends InheritClass implements ITimer {
+
+
+    duration = 1000;
+    alive = true;
+    thread({
+      timing,
+      intervalInterceptor,
+      duration
+    }:TTimerParams) {
+      const timer = this;
+
+      const start = performance.now();
+
+      requestAnimationFrame(function thread(time) {
+        // timeFraction goes from 0 to 1
+        const elapsed = (time - start);
+        let timeFraction = elapsed / duration;
+        if (timeFraction > 1) timeFraction = 1;
+
+        // calculate the current progress state
+        const progress = timing(timeFraction, elapsed);
+
+        intervalInterceptor(Math.round(progress * 100)); // draw it
+
+        if ((timeFraction < 1 || duration === -1) && timer.alive) {
+          requestAnimationFrame(thread);
+        }
+
+      });
+    }
+
+
+  }
+
+Package("com.qcobjects.timing", [
+    Timer
+  ]);

package/src/Toggle.ts

@@ -0,0 +1,65 @@
+import { InheritClass } from "./InheritClass";
+import { logger } from "./Logger";
+import { Package } from "./Package";
+export class Toggle extends InheritClass {
+  _toggle = false;
+  _inverse = true;
+  _positive:Function|null = null;
+  _negative:Function|null = null;
+  _dispatched:Function|null = null;
+  _args = {};
+
+  constructor(positive: Function, negative: Function, args: Array<any>) {
+    super({positive, negative, args});
+    this._new_({positive, negative, args});
+  }
+
+  changeToggle() {
+    this._toggle = !(this._toggle);
+  }
+
+  _new_({
+    positive,
+    negative,
+    args
+  }:{positive: Function, negative: Function, args: Array<any>}) {
+    this._positive = positive;
+    this._negative = negative;
+    this._args = args;
+  }
+
+  fire():Promise<Toggle> {
+    const toggle = this;
+    var _promise = new Promise<Toggle>(function (resolve, reject) {
+
+      if (typeof toggle._positive === "function" && typeof toggle._negative === "function") {
+        if (toggle._inverse) {
+          toggle._dispatched = (toggle._toggle) ? (toggle._negative.bind(toggle)) : (toggle._positive.bind(toggle));
+        } else {
+          toggle._dispatched = (toggle._toggle) ? (toggle._positive.bind(toggle)) : (toggle._negative.bind(toggle));
+        }
+        toggle._dispatched?.call(toggle, toggle._args);
+        resolve.call(_promise, toggle);
+      } else {
+        logger.debug("Toggle functions are not declared");
+        reject.call(_promise, toggle as Toggle);
+      }
+      return toggle;
+    }).then(function (toggle:Toggle) {
+      toggle.changeToggle();
+      return toggle;
+    }).catch(function (e) {
+      logger.debug(e.toString());
+      return toggle;
+    }).finally(()=> {
+      return toggle;
+    });
+    return _promise;
+  }
+
+
+}
+
+Package("com.qcobjects.tools.essentials", [
+  Toggle
+]);

package/src/TransitionEffect.ts

@@ -0,0 +1,80 @@
+import { Effect } from "./Effect";
+import { logger } from "./Logger";
+import { Package } from "./Package";
+import { ClassFactory } from "./ClassFactory";
+import { IComponent, IQCObjectsElement, IQCObjectsShadowedElement, ITransitionEffect, TTransitionEffectParams } from "types";
+
+export class TransitionEffect extends Effect implements ITransitionEffect{
+  duration = 385;
+  defaultParams = {
+    alphaFrom: 0,
+    alphaTo: 1,
+    angleFrom: 180,
+    angleTo: 0,
+    radiusFrom: 0,
+    radiusTo: 30,
+    scaleFrom: 0,
+    scaleTo: 1
+  };
+
+  fitToHeight = false;
+  fitToWidth = false;
+
+  component!: IComponent;
+  effects!: string[];
+
+  apply({
+    alphaFrom,
+    alphaTo,
+    angleFrom,
+    angleTo,
+    radiusFrom,
+    radiusTo,
+    scaleFrom,
+    scaleTo
+  }: TTransitionEffectParams) {
+    const _transition_ = this;
+    logger.info("EXECUTING TransitionEffect  ");
+    const componentRoot =_transition_.component.componentRoot as IQCObjectsElement | IQCObjectsShadowedElement | HTMLElement | ShadowRoot;
+
+    if (typeof componentRoot !== "undefined" && componentRoot !== null){
+      if (_transition_.fitToHeight) {
+        (componentRoot as any).height = (typeof (componentRoot as HTMLElement).offsetParent === "object" && (componentRoot as HTMLElement).offsetParent !== null) ? ((componentRoot as HTMLElement).offsetParent?.scrollHeight) : ((componentRoot as HTMLElement).getBoundingClientRect().height);
+      }
+      if (_transition_.fitToWidth) {
+        (componentRoot as any).width = (typeof (componentRoot as HTMLElement).offsetParent === "object" && (componentRoot as HTMLElement).offsetParent !== null) ? ((componentRoot as HTMLElement).offsetParent?.scrollWidth) : ((componentRoot as HTMLElement).getBoundingClientRect().width);
+      }
+      if (_transition_.component.shadowed){
+        ((componentRoot as ShadowRoot).host as HTMLElement).style.display = "block";
+      } else {
+        (componentRoot as HTMLElement).style.display = "block";
+      }
+      _transition_.effects.map( (effectClassName:string):string => {
+
+        const __effectClass__ = ClassFactory(effectClassName) as unknown as typeof Effect;
+        const effectObj = new __effectClass__({});
+        const effectClassMethod = effectObj.apply.bind(_transition_);
+        const componentHost = (_transition_.component.shadowed)? ((componentRoot as ShadowRoot).host) : (componentRoot);
+        const effectParams = {
+          alphaFrom,
+          alphaTo,
+          angleFrom,
+          angleTo,
+          radiusFrom,
+          radiusTo,
+          scaleFrom,
+          scaleTo
+        };        
+        effectClassMethod(componentHost,...Object.values(effectParams));
+        return effectClassName;
+      });
+  
+    }
+
+  }
+
+}
+
+Package("com.qcobjects.effects.transitions.base", [
+  TransitionEffect
+]);

package/src/VO.ts

@@ -0,0 +1,8 @@
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+
+export class VO extends InheritClass {}
+
+Package("com.qcobjects.valueObjects", [
+    VO
+  ]);

package/src/View.ts

@@ -0,0 +1,17 @@
+import { __getType__ } from "./getType";
+import { InheritClass } from "./InheritClass";
+import { Package } from "./Package";
+
+export class View extends InheritClass {
+    constructor({ component = undefined, dependencies = [] }) {
+      super({component, dependencies});
+      if (typeof this.component === "undefined" || this.component === "null") {
+        throw Error(`${__getType__(this)} must be called with a component`);
+      }
+
+    }
+  }
+
+Package("com.qcobjects.views", [
+    View
+]);