bard-legends-framework 0.9.5 → 0.9.7

package/dist/lib/libraries/animator/animator.js

@@ -1,20 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const update_loop_1 = require("../../../game-entities/update-loop");
-const animations_1 = require("./animations");
+const helpers_lib_1 = require('helpers-lib');
+const update_loop_1 = require('../../../game-entities/update-loop');
+const animations_1 = require('./animations');
 var ReAnimateHandlingType;
-(function (ReAnimateHandlingType) {
-    ReAnimateHandlingType["throwError"] = "throwError";
-    ReAnimateHandlingType["ignore"] = "ignore";
-    // TODO: blendIn
+(ReAnimateHandlingType => {
+  ReAnimateHandlingType['throwError'] = 'throwError';
+  ReAnimateHandlingType['ignore'] = 'ignore';
+  // TODO: blendIn
 })(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
 var CompleteAnimationsHandlingType;
-(function (CompleteAnimationsHandlingType) {
-    CompleteAnimationsHandlingType["returnToOriginal"] = "returnToOriginal";
-    CompleteAnimationsHandlingType["stayInCurrentState"] = "stayInCurrentState";
-    CompleteAnimationsHandlingType["jumpToEnd"] = "jumpToEnd";
+(CompleteAnimationsHandlingType => {
+  CompleteAnimationsHandlingType['returnToOriginal'] = 'returnToOriginal';
+  CompleteAnimationsHandlingType['stayInCurrentState'] = 'stayInCurrentState';
+  CompleteAnimationsHandlingType['jumpToEnd'] = 'jumpToEnd';
 })(CompleteAnimationsHandlingType || (exports.CompleteAnimationsHandlingType = CompleteAnimationsHandlingType = {}));
 const DEFAULT_DURATION = 200;
 const DEFAULT_ANIMATION = new animations_1.AnimationLineer();
@@ -22,201 +21,199 @@ const DEFAULT_LOOP = false;
 const DEFAULT_RE_ANIMATE_HANDLING = ReAnimateHandlingType.throwError;
 const DEFAULT_COMPLETE_ANIMATIONS_HANDLING = CompleteAnimationsHandlingType.stayInCurrentState;
 class Animator {
-    static { this.animatedObjects = new Set(); }
-    constructor(target, effectOn, options = {}) {
-        this.effectOn = new Set();
-        this.running = true;
-        this.propertyStates = new Map();
-        if (!helpers_lib_1.Comparator.isObject(target)) {
-            throw new Error(`Animator: target is not an object! Target: '${target}'`);
-        }
-        else if (Animator.animatedObjects.has(target)) {
-            throw new Error(`Animator: target is already animated! Target: '${target}'`);
-        }
-        else {
-            Animator.animatedObjects.add(target);
-        }
-        this.targetObject = target;
-        this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
-        this.defaultDuration = options.duration || DEFAULT_DURATION;
-        this.defaultAnimation = options.animation || DEFAULT_ANIMATION;
-        this.defaultLoop = options.loop || DEFAULT_LOOP;
-        this.defaultReAnimateHandling = options.reAnimateHandling || DEFAULT_RE_ANIMATE_HANDLING;
-        this.defaultCompleteAnimationsHandling = options.completeAnimationsHandling || DEFAULT_COMPLETE_ANIMATIONS_HANDLING;
-        this.effectOn.forEach(key => {
-            if (!helpers_lib_1.Comparator.hasProperty(target, key)) {
-                throw new Error(`Animator: target does not have target property. Target property: '${key}'`);
-            }
-            else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
-                throw new Error(`Animator: target property is not a number. Target property: '${key}'`);
-            }
-        });
+  static {
+    Animator.animatedObjects = new Set();
+  }
+  constructor(target, effectOn, options = {}) {
+    this.effectOn = new Set();
+    this.running = true;
+    this.propertyStates = new Map();
+    if (!helpers_lib_1.Comparator.isObject(target)) {
+      throw new Error(`Animator: target is not an object! Target: '${target}'`);
+    } else if (Animator.animatedObjects.has(target)) {
+      throw new Error(`Animator: target is already animated! Target: '${target}'`);
+    } else {
+      Animator.animatedObjects.add(target);
     }
-    get isAnimating() {
-        return this.propertyStates.size > 0;
+    this.targetObject = target;
+    this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
+    this.defaultDuration = options.duration || DEFAULT_DURATION;
+    this.defaultAnimation = options.animation || DEFAULT_ANIMATION;
+    this.defaultLoop = options.loop || DEFAULT_LOOP;
+    this.defaultReAnimateHandling = options.reAnimateHandling || DEFAULT_RE_ANIMATE_HANDLING;
+    this.defaultCompleteAnimationsHandling = options.completeAnimationsHandling || DEFAULT_COMPLETE_ANIMATIONS_HANDLING;
+    this.effectOn.forEach(key => {
+      if (!helpers_lib_1.Comparator.hasProperty(target, key)) {
+        throw new Error(`Animator: target does not have target property. Target property: '${key}'`);
+      } else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
+        throw new Error(`Animator: target property is not a number. Target property: '${key}'`);
+      }
+    });
+  }
+  get isAnimating() {
+    return this.propertyStates.size > 0;
+  }
+  getAnimationStateOfKey(key) {
+    const propertyState = this.propertyStates.get(key);
+    if (propertyState) {
+      return {
+        duration: propertyState.duration,
+        elapsedTime: propertyState.elapsedTime,
+        startingValue: propertyState.startingValue,
+        targetValue: propertyState.targetValue,
+        loop: propertyState.loop,
+        completeAnimationsHandling: propertyState.completeAnimationsHandling
+      };
     }
-    getAnimationStateOfKey(key) {
-        let propertyState = this.propertyStates.get(key);
-        if (propertyState) {
-            return {
-                duration: propertyState.duration,
-                elapsedTime: propertyState.elapsedTime,
-                startingValue: propertyState.startingValue,
-                targetValue: propertyState.targetValue,
-                loop: propertyState.loop,
-                completeAnimationsHandling: propertyState.completeAnimationsHandling
-            };
-        }
+  }
+  onChange(callback) {
+    if (this.onChangeCallback) {
+      throw new Error('Animator: onChangeCallback is already set!');
     }
-    onChange(callback) {
-        if (this.onChangeCallback) {
-            throw new Error('Animator: onChangeCallback is already set!');
+    this.onChangeCallback = callback;
+    return this;
+  }
+  pauseAnimations() {
+    this.running = false;
+  }
+  resumeAnimations() {
+    this.running = true;
+  }
+  completeAnimations(completeAnimationsHandling) {
+    const triggerOnChange = this.isAnimating;
+    this.propertyStates.forEach((value, key) => {
+      const completeAnimationsHandlingFinal = completeAnimationsHandling || value.completeAnimationsHandling;
+      if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
+        this.targetObject[key] = value.startingValue;
+      } else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
+        this.targetObject[key] = value.targetValue;
+      }
+      value.completionCallback();
+      this.propertyStates.delete(key);
+    });
+    triggerOnChange && this.onChangeCallback?.(this.targetObject);
+  }
+  set(values) {
+    Object.keys(values).forEach(key => {
+      this.checkPropertyValidity(key);
+      if (this.propertyStates.get(key)) {
+        throw new Error(`Animator: property is already being animated. Property: '${key}'`);
+      }
+    });
+    let triggerOnChange = false;
+    Object.keys(values).forEach(key => {
+      triggerOnChange = triggerOnChange || this.targetObject[key] !== values[key];
+      this.targetObject[key] = values[key];
+    });
+    triggerOnChange && this.onChangeCallback?.(this.targetObject);
+  }
+  async animate(values, options = {}) {
+    const valueKeys = Object.keys(values);
+    valueKeys.forEach(key => {
+      this.checkPropertyValidity(key);
+    });
+    return this.startAnimate(values, options);
+  }
+  startAnimate(values, options = {}) {
+    const reAnimateHandling = options.reAnimateHandling || this.defaultReAnimateHandling;
+    Object.keys(values).forEach(key => {
+      const previousState = this.propertyStates.get(key);
+      if (previousState) {
+        if (reAnimateHandling === ReAnimateHandlingType.throwError) {
+          throw new Error(`Animator: property is already being animated. Property: '${key}'`);
+        } else if (reAnimateHandling === ReAnimateHandlingType.ignore) {
+          delete values[key];
         }
-        this.onChangeCallback = callback;
-        return this;
-    }
-    pauseAnimations() {
-        this.running = false;
-    }
-    resumeAnimations() {
-        this.running = true;
-    }
-    completeAnimations(completeAnimationsHandling) {
-        let triggerOnChange = this.isAnimating;
-        this.propertyStates.forEach((value, key) => {
-            let completeAnimationsHandlingFinal = completeAnimationsHandling || value.completeAnimationsHandling;
-            if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
-                this.targetObject[key] = value.startingValue;
-            }
-            else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
-                this.targetObject[key] = value.targetValue;
+      }
+    });
+    return new Promise(resolveAll => {
+      Promise.all(
+        Object.keys(values).map(
+          key =>
+            new Promise(resolve => {
+              const duration = options.duration || this.defaultDuration;
+              const animation = options.animation || this.defaultAnimation;
+              const loop = options.loop || this.defaultLoop;
+              const completeAnimationsHandling = options.completeAnimationsHandling || this.defaultCompleteAnimationsHandling;
+              animation.start();
+              try {
+                this.propertyStates.set(key, {
+                  duration,
+                  animation,
+                  elapsedTime: 0,
+                  startingValue: this.targetObject[key],
+                  targetValue: values[key],
+                  loop,
+                  completeAnimationsHandling,
+                  completionCallback: () => {
+                    resolve(undefined);
+                  }
+                });
+              } catch (e) {
+                resolveAll();
+              }
+            })
+        )
+      ).then(() => {
+        resolveAll();
+      });
+      this.subscribeUpdateCycle();
+    });
+  }
+  update(delta) {
+    if (this.running) {
+      const triggerOnChange = this.propertyStates.size;
+      this.propertyStates.forEach((value, key) => {
+        value.elapsedTime += delta;
+        let animationIsCompete = value.elapsedTime >= value.duration;
+        if (animationIsCompete) {
+          if (value.loop) {
+            value.animation.start();
+            value.elapsedTime -= value.duration;
+            animationIsCompete = false;
+          } else {
+            if (value.completeAnimationsHandling === CompleteAnimationsHandlingType.returnToOriginal) {
+              this.targetObject[key] = value.startingValue;
+            } else {
+              this.targetObject[key] = value.targetValue;
             }
             value.completionCallback();
             this.propertyStates.delete(key);
-        });
-        triggerOnChange && this.onChangeCallback?.(this.targetObject);
-    }
-    set(values) {
-        Object.keys(values).forEach(key => {
-            this.checkPropertyValidity(key);
-            if (this.propertyStates.get(key)) {
-                throw new Error(`Animator: property is already being animated. Property: '${key}'`);
-            }
-        });
-        let triggerOnChange = false;
-        Object.keys(values).forEach(key => {
-            triggerOnChange = triggerOnChange || this.targetObject[key] !== values[key];
-            this.targetObject[key] = values[key];
-        });
-        triggerOnChange && this.onChangeCallback?.(this.targetObject);
-    }
-    async animate(values, options = {}) {
-        let valueKeys = Object.keys(values);
-        valueKeys.forEach(key => {
-            this.checkPropertyValidity(key);
-        });
-        return this.startAnimate(values, options);
-    }
-    startAnimate(values, options = {}) {
-        let reAnimateHandling = options.reAnimateHandling || this.defaultReAnimateHandling;
-        Object.keys(values).forEach(key => {
-            let previousState = this.propertyStates.get(key);
-            if (previousState) {
-                if (reAnimateHandling === ReAnimateHandlingType.throwError) {
-                    throw new Error(`Animator: property is already being animated. Property: '${key}'`);
-                }
-                else if (reAnimateHandling === ReAnimateHandlingType.ignore) {
-                    delete values[key];
-                }
-            }
-        });
-        return new Promise(resolveAll => {
-            Promise.all(Object.keys(values).map(key => new Promise(resolve => {
-                let duration = options.duration || this.defaultDuration;
-                let animation = options.animation || this.defaultAnimation;
-                let loop = options.loop || this.defaultLoop;
-                let completeAnimationsHandling = options.completeAnimationsHandling || this.defaultCompleteAnimationsHandling;
-                animation.start();
-                try {
-                    this.propertyStates.set(key, {
-                        duration,
-                        animation,
-                        elapsedTime: 0,
-                        startingValue: this.targetObject[key],
-                        targetValue: values[key],
-                        loop,
-                        completeAnimationsHandling,
-                        completionCallback: () => {
-                            resolve(undefined);
-                        }
-                    });
-                }
-                catch (e) {
-                    resolveAll();
-                }
-            }))).then(() => {
-                resolveAll();
-            });
-            this.subscribeUpdateCycle();
-        });
-    }
-    update(delta) {
-        if (this.running) {
-            let triggerOnChange = this.propertyStates.size;
-            this.propertyStates.forEach((value, key) => {
-                value.elapsedTime += delta;
-                let animationIsCompete = value.elapsedTime >= value.duration;
-                if (animationIsCompete) {
-                    if (value.loop) {
-                        value.animation.start();
-                        value.elapsedTime -= value.duration;
-                        animationIsCompete = false;
-                    }
-                    else {
-                        if (value.completeAnimationsHandling === CompleteAnimationsHandlingType.returnToOriginal) {
-                            this.targetObject[key] = value.startingValue;
-                        }
-                        else {
-                            this.targetObject[key] = value.targetValue;
-                        }
-                        value.completionCallback();
-                        this.propertyStates.delete(key);
-                    }
-                }
-                if (!animationIsCompete) {
-                    let multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
-                    let relativeTarget = value.targetValue - value.startingValue;
-                    this.targetObject[key] = relativeTarget * multiplier + value.startingValue;
-                }
-            });
-            triggerOnChange && this.onChangeCallback?.(this.targetObject);
-            if (this.propertyStates.size <= 0) {
-                this.updateCycleSubscription?.unsubscribe();
-            }
+          }
         }
-    }
-    subscribeUpdateCycle() {
+        if (!animationIsCompete) {
+          const multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
+          const relativeTarget = value.targetValue - value.startingValue;
+          this.targetObject[key] = relativeTarget * multiplier + value.startingValue;
+        }
+      });
+      triggerOnChange && this.onChangeCallback?.(this.targetObject);
+      if (this.propertyStates.size <= 0) {
         this.updateCycleSubscription?.unsubscribe();
-        this.updateCycleSubscription = update_loop_1.UpdateCycle.updateAction
-            .subscribe(update => {
-            try {
-                this.update(update.delta);
-            }
-            catch (e) {
-                this.propertyStates.forEach(value => {
-                    value.completionCallback();
-                });
-                this.propertyStates = new Map();
-                this.updateCycleSubscription?.unsubscribe();
-            }
-        })
-            .skipAttachCheck();
+      }
     }
-    checkPropertyValidity(key) {
-        if (!this.effectOn.has(key)) {
-            throw new Error(`Animator: not effected property is tried to update. Key: '${key}', EffectOn: '${this.effectOn}'`);
+  }
+  subscribeUpdateCycle() {
+    this.updateCycleSubscription?.unsubscribe();
+    this.updateCycleSubscription = update_loop_1.UpdateCycle.updateAction
+      .subscribe(update => {
+        try {
+          this.update(update.delta);
+        } catch (e) {
+          this.propertyStates.forEach(value => {
+            value.completionCallback();
+          });
+          this.propertyStates = new Map();
+          this.updateCycleSubscription?.unsubscribe();
         }
+      })
+      .skipAttachCheck();
+  }
+  checkPropertyValidity(key) {
+    if (!this.effectOn.has(key)) {
+      throw new Error(`Animator: not effected property is tried to update. Key: '${key}', EffectOn: '${this.effectOn}'`);
     }
+  }
 }
 exports.Animator = Animator;
-//# sourceMappingURL=animator.js.map
+//# sourceMappingURL=animator.js.map