bard-legends-framework 0.11.0 → 0.12.0

package/dist/utilities/animator/animator_old/animator.test.js

@@ -0,0 +1,996 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const actions_lib_1 = require("actions-lib");
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../game-entities");
+const animations_1 = require("../animations");
+const animator_1 = require("./animator");
+(0, vitest_1.describe)('ANIMATOR', () => {
+    (0, vitest_1.describe)('Setup', () => {
+        (0, vitest_1.test)('constructor should throw error if target is not an object', () => {
+            let obj = 'string';
+            (0, vitest_1.expect)(() => {
+                new animator_1.Animator(obj, 'x').attachToRoot();
+            }).toThrow('Animator: target is not an object! Target: "string"');
+        });
+        (0, vitest_1.test)('constructor should throw error if target does not have all target properties', () => {
+            let obj = { x: 1, y: 2, z: 3 };
+            (0, vitest_1.expect)(() => {
+                new animator_1.Animator(obj, ['x', 't']).attachToRoot();
+            }).toThrow('Animator: target does not have property. Target property: "t"');
+        });
+        (0, vitest_1.test)('constructor should throw error if target property is not a number', () => {
+            let obj = { x: 'fail' };
+            (0, vitest_1.expect)(() => {
+                new animator_1.Animator(obj, ['x']).attachToRoot();
+            }).toThrow('Animator: target property is not a number. Target property: "x"');
+        });
+        (0, vitest_1.test)('animate should throw error if non effected property tried to animate', () => {
+            (0, vitest_1.expect)(() => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, ['x', 't']).attachToRoot();
+                animator.animate({ x: 5, y: 5 });
+            }).toThrow('Animator: target does not have property. Target property: "t"');
+        });
+        (0, vitest_1.test)('should throw error if multiple animators decorate the same property', () => {
+            (0, vitest_1.expect)(() => {
+                let obj = { x: 0 };
+                new animator_1.Animator(obj, 'x').attachToRoot();
+                new animator_1.Animator(obj, 'x').attachToRoot();
+            }).toThrow(`Animator: target property is already animated! Target: "{\n  "x": 0\n}", Property: "x"`);
+        });
+        (0, vitest_1.test)('setting multiple update callbacks should throw error', () => {
+            (0, vitest_1.expect)(() => {
+                let obj = { x: 0 };
+                new animator_1.Animator(obj, 'x')
+                    .onChange(() => { })
+                    .onChange(() => { })
+                    .attachToRoot();
+            }).toThrow('Animator: onChangeCallback is already set!');
+        });
+    });
+    (0, vitest_1.describe)('Animate', () => {
+        (0, vitest_1.test)('animate should not change the value before the update ticks', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x').attachToRoot();
+            animator.animate({ x: 5 }).attachToRoot();
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+        });
+        (0, vitest_1.test)('animate should not take action if the target value is the same', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4 }).attachToRoot();
+            animator.animate({ x: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+            (0, vitest_1.expect)(animator.animating).toEqual(false);
+        });
+        (0, vitest_1.test)('animate should take action if the target value is the same and the animation is loop', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, loop: true }).attachToRoot();
+            animator.animate({ x: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+            (0, vitest_1.expect)(animator.animating).toEqual(true);
+        });
+        (0, vitest_1.test)('animate to target in lineer', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('animate to target with overriden duration', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }, { duration: 2 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+        });
+        (0, vitest_1.test)('animate to target with overriden instant duration', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }, { duration: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('animate only one property should not effect the other', () => {
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1, y: 0 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2, y: 0 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 3, y: 0 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 4, y: 0 });
+        });
+        (0, vitest_1.test)('animate with custom values should override the default settings', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 10, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 10 }, { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 5 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 10 });
+        });
+        (0, vitest_1.test)('animate to target in easeInOut starting from zero', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ x: 10 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1.25);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(5);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(8.75);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(10);
+        });
+        (0, vitest_1.test)('animate to target in easeInOut starting from different value than zero', () => {
+            let obj = { x: 10 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ x: 20 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(11.25);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(15);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(18.75);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(20);
+        });
+        (0, vitest_1.test)('animate to target and return back', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }).attachToRoot();
+            animator['update'](1);
+            animator.animate({ x: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+        });
+        (0, vitest_1.test)('animate onChange callbacks', () => {
+            let obj = { x: 0 };
+            let valueFromOnStep = 0;
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.easeInOut })
+                .onChange(item => {
+                valueFromOnStep = item.x;
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            animator.animate({ x: 10 }).attachToRoot();
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(0);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(0);
+            animator['update'](1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(1.25);
+            animator['update'](1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(2);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(5);
+            animator['update'](1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(3);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(8.75);
+            animator['update'](1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(4);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(10);
+            animator['update'](1);
+            animator['update'](1);
+            animator['update'](1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(4);
+        });
+        (0, vitest_1.test)('animate onChange should not be triggered before starting the animation', () => {
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 4, animation: animations_1.Animations.easeInOut })
+                .onChange(() => {
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(0);
+        });
+        (0, vitest_1.test)('animation complete promise', () => {
+            let obj = { x: 0 };
+            let completed = false;
+            let animator = new animator_1.Animator(obj, 'x').attachToRoot();
+            animator
+                .animate({ x: 1 }, { duration: 2 })
+                .tap(() => {
+                completed = true;
+            })
+                .attachToRoot();
+            (0, vitest_1.expect)(completed).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed).toBeTruthy();
+        });
+        (0, vitest_1.test)('animate getter/setter property', () => {
+            class Foo {
+                constructor() {
+                    this._x = 10;
+                }
+                get x() {
+                    return this._x;
+                }
+                set x(value) {
+                    this._x = value;
+                }
+            }
+            let obj = new Foo();
+            let animator = new animator_1.Animator(obj, ['x'], { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ x: 20 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(11.25);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(15);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(18.75);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(20);
+        });
+        (0, vitest_1.test)('is animating should return true if it is animating', () => {
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 1, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            (0, vitest_1.expect)(animator.animating).toBeTruthy();
+        });
+        (0, vitest_1.test)('is animating should return false if it is not animating', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: animations_1.Animations.lineer }).attachToRoot();
+            (0, vitest_1.expect)(animator.animating).toBeFalsy();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(animator.animating).toBeFalsy();
+        });
+    });
+    (0, vitest_1.describe)('Animation Cycle Changes', () => {
+        (0, vitest_1.test)('pause animations should halt the progress', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2 });
+            animator.pauseAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2 });
+            animator.resumeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 3 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 4 });
+        });
+        (0, vitest_1.test)('new animations should not proceed while the animations are paused', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 2, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.pauseAnimations();
+            animator.animate({ x: 2 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 0 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 0 });
+            animator.resumeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2 });
+        });
+        (0, vitest_1.test)('animation loop', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 2, animation: animations_1.Animations.lineer, loop: true }).attachToRoot();
+            animator.animate({ x: 2 }, { duration: 2 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator['update'](0.8);
+            (0, vitest_1.expect)(obj.x).toEqual(1.8);
+            animator['update'](0.7);
+            (0, vitest_1.expect)(obj.x).toEqual(0.5);
+        });
+    });
+    (0, vitest_1.describe)('Set', () => {
+        (0, vitest_1.test)('it should throw error if it is animating', () => {
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 1 }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            (0, vitest_1.expect)(() => {
+                animator.set({ x: 0 });
+            }).toThrow();
+        });
+        (0, vitest_1.test)('it should throw error if the property is not valid', () => {
+            let animator = new animator_1.Animator({ x: 0 }, 'x').attachToRoot();
+            (0, vitest_1.expect)(() => {
+                animator.set({ t: 0 });
+            }).toThrow();
+        });
+        (0, vitest_1.test)('it should change the original value', () => {
+            let obj = { x: 0, y: 1, z: 2 };
+            let animator = new animator_1.Animator(obj, ['x', 'y', 'z']).attachToRoot();
+            animator.set({ x: 3, y: 4 });
+            (0, vitest_1.expect)(obj).toEqual({ x: 3, y: 4, z: 2 });
+        });
+        (0, vitest_1.test)('it should trigger onChange', () => {
+            let obj = { x: 0 };
+            let valueFromOnStep = 0;
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x')
+                .onChange(item => {
+                valueFromOnStep = item.x;
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            animator.set({ x: 1 });
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+        });
+        (0, vitest_1.test)('it should not trigger onChange if the value is the same', () => {
+            let obj = { x: 0 };
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x')
+                .onChange(() => {
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            animator.set({ x: 0 });
+            (0, vitest_1.expect)(onStepCallCount).toEqual(0);
+        });
+    });
+    (0, vitest_1.describe)('Reanimate', () => {
+        (0, vitest_1.test)('re-animation handling option throw error should throw error', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.throwError
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            (0, vitest_1.expect)(() => animator.animate({ x: 0 }).attachToRoot()).toThrow('Animator: property is already being animated. Property: "x"');
+            animator['update'](1);
+            (0, vitest_1.expect)(() => animator.animate({ x: 0 }).attachToRoot()).toThrow('Animator: property is already being animated. Property: "x"');
+            animator['update'](3);
+            (0, vitest_1.expect)(() => animator.animate({ x: 0 }).attachToRoot()).not.toThrow('Animator: property is already being animated. Property: "x"');
+        });
+        (0, vitest_1.test)('re-animation handling option ignore should ignore new animation', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 1,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.ignoreNewAnimation
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator.animate({ x: 2 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+        });
+        (0, vitest_1.test)('re-animation handling option ignore should ignore multiple property animation', () => {
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], {
+                duration: 1,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.ignoreNewAnimation
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator.animate({ x: 2, y: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1, y: 1 });
+        });
+        (0, vitest_1.test)('animate switch after finishes to a different animation type should not throw error', () => {
+            let obj = { x: 1 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1 }).attachToRoot();
+            animator.animate({ x: 0 }, { animation: animations_1.Animations.lineer }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+            animator.animate({ x: 10 }, { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1.25);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(5);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(8.75);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(10);
+        });
+        (0, vitest_1.test)('re-animation handling option canceling should cancel the ongoing animation', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 1,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator.animate({ x: 2 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+        });
+        (0, vitest_1.test)('re-animation handling option canceling should cancel the ongoing multiple property animation', () => {
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], {
+                duration: 1,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator.animate({ x: 2, y: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2, y: 1 });
+        });
+        (0, vitest_1.test)('re-animation handling option canceling should cancel the animation with keeping the current value', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 2,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious
+            }).attachToRoot();
+            animator.animate({ x: 2 }).attachToRoot();
+            animator['update'](1);
+            animator.animate({ x: 3 }).attachToRoot();
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+        });
+        (0, vitest_1.test)('reanimate ignore new animation', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.ignoreNewAnimation
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0.25);
+            animator.animate({ x: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0.5);
+        });
+        (0, vitest_1.test)('reanimate start new animation', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0.25);
+            animator.animate({ x: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0.1875);
+        });
+        (0, vitest_1.test)('reanimation triggered completion destroys the object should not make the new animation to throw error', async () => {
+            class AnimationObject extends actions_lib_1.Attachable {
+                constructor() {
+                    super(...arguments);
+                    this.scale = 1;
+                }
+            }
+            let object = new AnimationObject().attachToRoot();
+            let animator = new animator_1.Animator(object, 'scale', {
+                duration: 4,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+            }).attach(object);
+            let completed1 = false;
+            let completed2 = false;
+            animator
+                .animate({ scale: 2 })
+                .tap(() => {
+                completed1 = true;
+                object.destroy();
+            })
+                .attachToRoot();
+            animator
+                .animate({ scale: 3 })
+                .tap(() => {
+                completed2 = true;
+            })
+                .attach(object);
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+            (0, vitest_1.expect)(completed2).toBeFalsy();
+        });
+        (0, vitest_1.test)('reanimation triggered completion animates the same property should not interfier with the new animation', async () => {
+            class AnimationObject extends actions_lib_1.Attachable {
+                constructor() {
+                    super(...arguments);
+                    this.scale = 1;
+                }
+            }
+            let object = new AnimationObject().attachToRoot();
+            let animator = new animator_1.Animator(object, 'scale', {
+                duration: 4,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+            }).attach(object);
+            let animation1Complete = false;
+            let completed1 = false;
+            let completed2 = false;
+            animator
+                .animate({ scale: 2 })
+                .asyncMap(() => {
+                animation1Complete = true;
+                return animator.animate({ scale: 1 });
+            })
+                .tap(() => {
+                completed1 = true;
+                object.destroy();
+            })
+                .attachToRoot();
+            animator['update'](1);
+            animator
+                .animate({ scale: 1 })
+                .tap(() => {
+                completed2 = true;
+            })
+                .attach(object);
+            (0, vitest_1.expect)(animation1Complete).toBeTruthy();
+            (0, vitest_1.expect)(completed1).toBeFalsy();
+            (0, vitest_1.expect)(completed2).toBeTruthy();
+            animator['update'](4);
+            (0, vitest_1.expect)(animation1Complete).toBeTruthy();
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+            (0, vitest_1.expect)(completed2).toBeTruthy();
+        });
+    });
+    (0, vitest_1.describe)('Complete Animations', () => {
+        (0, vitest_1.test)('when animation is done it should respect the complete animaitons option', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 1,
+                animation: animations_1.Animations.lineer,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.returnToOriginal
+            }).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+        });
+        (0, vitest_1.test)('complete animations should finalize the ongoing animation', () => {
+            let obj = { x: 0 };
+            let completed = false;
+            let animator = new animator_1.Animator(obj, 'x').attachToRoot();
+            animator
+                .animate({ x: 1 }, { duration: 4 })
+                .tap(() => {
+                completed = true;
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed).toBeFalsy();
+            animator.completeAnimations();
+            (0, vitest_1.expect)(completed).toBeTruthy();
+        });
+        (0, vitest_1.test)('complete animations should finalize the all ongoing animations', () => {
+            let completed1 = false;
+            let completed2 = false;
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator
+                .animate({ y: 10 }, { loop: true })
+                .tap(() => {
+                completed1 = true;
+            })
+                .attachToRoot();
+            animator['update'](1);
+            animator
+                .animate({ x: 10 })
+                .tap(() => {
+                completed2 = true;
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed1).toBeFalsy();
+            (0, vitest_1.expect)(completed2).toBeFalsy();
+            animator.completeAnimations();
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+            (0, vitest_1.expect)(completed2).toBeTruthy();
+        });
+        (0, vitest_1.test)('complete animations stay in current state', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x').attachToRoot();
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+        });
+        (0, vitest_1.test)('complete animations jump to end', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x').attachToRoot();
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.jumpToEnd
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('complete animations return to original', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x').attachToRoot();
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.returnToOriginal
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+        });
+        (0, vitest_1.test)('complete animations options overriden in animate', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.returnToOriginal
+            }).attachToRoot();
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.jumpToEnd
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('complete animations options overriden in complete animations funciton', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.returnToOriginal
+            }).attachToRoot();
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.jumpToEnd
+            })
+                .attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimations(animator_1.CompleteAnimationsHandlingType.stayInCurrentState);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+        });
+        (0, vitest_1.test)('complete animations should not trigger onChange at stay in current state', () => {
+            let obj = { x: 0 };
+            let heap = [];
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+            })
+                .onChange(value => heap.push(value.x))
+                .attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            heap = [];
+            animator.completeAnimations();
+            (0, vitest_1.expect)(heap).toEqual([]);
+        });
+        (0, vitest_1.test)('complete animations should trigger onChange jump to end', () => {
+            let obj = { x: 0 };
+            let heap = [];
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.jumpToEnd })
+                .onChange(value => heap.push(value.x))
+                .attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            heap = [];
+            animator.completeAnimations();
+            (0, vitest_1.expect)(heap).toEqual([1]);
+        });
+        (0, vitest_1.test)('complete animations should trigger onChange return to original', () => {
+            let obj = { x: 0 };
+            let heap = [];
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.returnToOriginal
+            })
+                .onChange(value => heap.push(value.x))
+                .attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            heap = [];
+            animator.completeAnimations();
+            (0, vitest_1.expect)(heap).toEqual([0]);
+        });
+        (0, vitest_1.test)('complete animations should not trigger on change if it is not animating', () => {
+            let completed = false;
+            let animator = new animator_1.Animator({ x: 0 }, 'x')
+                .onChange(() => {
+                completed = true;
+            })
+                .attachToRoot();
+            animator.completeAnimations();
+            (0, vitest_1.expect)(completed).toBeFalsy();
+        });
+        (0, vitest_1.test)('complete animations should not trigger on change if the value change is already triggered', () => {
+            let obj = { x: 0 };
+            let heap = [];
+            let animator = new animator_1.Animator(obj, 'x', { duration: 2 }).onChange(value => heap.push(value.x)).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            animator.completeAnimations();
+            (0, vitest_1.expect)(heap).toEqual([0.5]);
+        });
+        (0, vitest_1.test)('complete animations options should take effect with set', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious
+            }).attachToRoot();
+            animator.animate({ x: 4 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.set({ x: 1 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+        });
+    });
+    (0, vitest_1.describe)('Compete Callback', () => {
+        (0, vitest_1.test)('complete callback should trigger when the animation is done', () => {
+            let obj = { x: 0 };
+            let completed = false;
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1 }).onComplete(() => (completed = true)).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed).toBeTruthy();
+        });
+        (0, vitest_1.test)('complete callback should trigger on reanimation', () => {
+            let obj = { x: 0 };
+            let heap = [];
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 2,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious,
+                completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+            })
+                .onComplete((key, value) => heap.push(value))
+                .attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            animator.animate({ x: 2 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(heap).toEqual([0.5]);
+            animator['update'](1);
+            (0, vitest_1.expect)(heap).toEqual([0.5, 2]);
+        });
+        (0, vitest_1.test)('complete callback should not trigger when the animation is not done', () => {
+            let completed = false;
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 1 }).onComplete(() => (completed = true)).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            (0, vitest_1.expect)(completed).toBeFalsy();
+        });
+        (0, vitest_1.test)('re-animate should take action in complete callback', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 2 }).attachToRoot();
+            animator.onComplete(() => {
+                animator.animate({ x: 0 }).attachToRoot();
+            });
+            animator.animate({ x: 1 }).attachToRoot();
+            animator['update'](2);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(0.5);
+        });
+    });
+    (0, vitest_1.describe)('Mixing Different Configurations', () => {
+        (0, vitest_1.test)('animate multiple properties without mixing animation type', () => {
+            let obj = { x: 0, y: 10 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ x: 10, y: 0 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25, y: 8.75 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 5, y: 5 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75, y: 1.25 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 10, y: 0 });
+        });
+        (0, vitest_1.test)('animate multiple properties with mixing animation type', () => {
+            let obj = { x: 0, y: 4 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4 }).attachToRoot();
+            animator.animate({ x: 10 }, { animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ y: 0 }, { animation: animations_1.Animations.lineer }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25, y: 3 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 5, y: 2 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75, y: 1 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 10, y: 0 });
+        });
+        (0, vitest_1.test)('animate multiple properties async', () => {
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ y: 10 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 0, y: 1.25 });
+            animator.animate({ x: 10 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25, y: 5 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 5, y: 8.75 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75, y: 10 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 10, y: 10 });
+        });
+        (0, vitest_1.test)('animate multiple properties mixed with loop', () => {
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            animator.animate({ y: 10 }, { loop: true }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 0, y: 1.25 });
+            animator.animate({ x: 10 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25, y: 5 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 5, y: 8.75 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75, y: 0 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 10, y: 1.25 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 10, y: 5 });
+        });
+        (0, vitest_1.test)('animate multiple properties complete promise', () => {
+            let completed1 = false;
+            let completed2 = false;
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4 }).attachToRoot();
+            animator
+                .animate({ y: 10 })
+                .tap(() => {
+                completed1 = true;
+            })
+                .attachToRoot();
+            animator['update'](1);
+            animator
+                .animate({ x: 10 })
+                .tap(() => {
+                completed2 = true;
+            })
+                .attachToRoot();
+            animator['update'](2);
+            (0, vitest_1.expect)(completed1).toBeFalsy();
+            (0, vitest_1.expect)(completed2).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+            (0, vitest_1.expect)(completed2).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+            (0, vitest_1.expect)(completed2).toBeTruthy();
+        });
+        (0, vitest_1.test)('pause animations with mixed commands', () => {
+            let obj = { x: 0, y: 0 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.resumeAnimations();
+            animator.animate({ x: 4 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 1, y: 0 });
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2, y: 0 });
+            animator.pauseAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2, y: 0 });
+            animator.pauseAnimations();
+            animator.animate({ y: 4 }).attachToRoot();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 2, y: 0 });
+            animator.resumeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 3, y: 1 });
+            animator.resumeAnimations();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj).toEqual({ x: 4, y: 2 });
+        });
+    });
+    (0, vitest_1.describe)('Update Cycle', () => {
+        (0, vitest_1.test)('testing with update cycle', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }).attachToRoot();
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+    });
+    (0, vitest_1.describe)('Destroyed Animator', () => {
+        (0, vitest_1.test)('destroyed animator should not animate', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.destroy();
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            animator.animate({ x: 1 }).attachToRoot();
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+        });
+        (0, vitest_1.test)('after destroy animation should not trigger complete', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: animations_1.Animations.lineer }).attachToRoot();
+            let animation = animator.animate({ x: 1 });
+            animator.destroy();
+            let triggered = false;
+            animation
+                .tap(() => {
+                triggered = true;
+            })
+                .attachToRoot();
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(triggered).toBeFalsy();
+        });
+        (0, vitest_1.test)('destroying animator should destroy the animation that attached to that animator', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator.animate({ x: 4 }).attach(animator);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+            animator.destroy();
+            animator['update'](1);
+            animator['update'](1);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+        });
+        (0, vitest_1.test)('animation sequence destroys the animator that it is being attached to', () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer }).attachToRoot();
+            animator
+                .animate({ x: 4 })
+                .tap(() => animator.destroy())
+                .attach(animator);
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            (0, vitest_1.expect)(animator.destroyed).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+            (0, vitest_1.expect)(animator.destroyed).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+            (0, vitest_1.expect)(animator.destroyed).toBeFalsy();
+            animator['update'](1);
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+            (0, vitest_1.expect)(animator.destroyed).toBeTruthy();
+        });
+    });
+});
+//# sourceMappingURL=animator.test.js.map