bard-legends-framework 0.11.0 → 0.12.1

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

@@ -0,0 +1,1046 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../game-entities");
+const animations_1 = require("../animations");
+const animator_1 = require("./animator");
+async function skipTime(duration = 1) {
+    await (0, helpers_lib_1.Wait)();
+    game_entities_1.UpdateCycle.triggerUpdateTick(duration);
+}
+(0, vitest_1.describe)('ANIMATOR', () => {
+    (0, vitest_1.beforeEach)(() => {
+        game_entities_1.BardLegendsHardReset.hardReset();
+    });
+    (0, vitest_1.describe)('Setup', () => {
+        (0, vitest_1.test)('type complains', () => {
+            let animator1 = new animator_1.Animator({ x: 0 }, 'x');
+            animator1.animate({ x: 1 }).attachToRoot();
+            let animator2 = new animator_1.Animator({ x: 0, y: 0, z: 'a', t: 0 }, ['x', 'y']);
+            animator2.animate({ x: 1, y: 2 }).attachToRoot();
+            try {
+                // @ts-expect-error should complain target has to be object
+                new animator_1.Animator('a', 'x');
+                // @ts-expect-error should complain target.y is not a number
+                new animator_1.Animator({ x: 0, y: 'a' }, 'y');
+                // @ts-expect-error should complain target.z does not exist
+                new animator_1.Animator({ x: 0, y: 'a' }, 'z');
+                let animator3 = new animator_1.Animator({ x: 0, y: 'a' }, 'x');
+                // @ts-expect-error should complain animate values should have all animatedProperties
+                animator3.animate({});
+                let animator4 = new animator_1.Animator({ x: 0, y: 0, z: 'a' }, ['x', 'y']);
+                // @ts-expect-error should complain animate values should have all animatedProperties
+                animator4.animate({ x: 1 });
+                // @ts-expect-error should complain z is not a number
+                new animator_1.Animator({ x: 0, y: 0, z: 'a' }, ['x', 'z']);
+                let animator5 = new animator_1.Animator({ x: 0, y: 0, z: 'a' }, ['x']);
+                // @ts-expect-error should complain y is not in the animatedProperties
+                animator5.animate({ x: 1, y: 2 });
+            }
+            catch { }
+            class Foo1 {
+                constructor() {
+                    this.x = 0;
+                    this.animator = new animator_1.Animator(this, 'x');
+                }
+            }
+            new Foo1();
+            class Foo2 {
+                constructor() {
+                    this.x = 0;
+                    this.y = 0;
+                    this.animator = new animator_1.Animator(this, ['x', 'y']);
+                }
+            }
+            new Foo2();
+        });
+        (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');
+                new animator_1.Animator(obj, 'x');
+            }).toThrow(`Animator: target property is already animated! Target: "{\n  "x": 0\n}", Property: "x"`);
+        });
+        (0, vitest_1.test)('when target is cleaned up from memory, it should be cleaned up from animated objects', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x');
+            (0, vitest_1.expect)(animator).toBeDefined();
+            (0, vitest_1.expect)(animator_1.Animator['_animatedObjects'].has(obj)).toBeTruthy();
+            obj = undefined;
+            await helpers_lib_1.UnitTestHelper.forceGarbageCollection();
+            (0, vitest_1.expect)(animator_1.Animator['_animatedObjects'].has(obj)).toBeFalsy();
+        });
+        (0, vitest_1.test)('when an animator is cleaned up from memory, it should be cleaned up from animated properties', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x');
+            (0, vitest_1.expect)(animator).toBeDefined();
+            (0, vitest_1.expect)(animator_1.Animator['_animatedObjects'].get(obj)?.has('x')).toBeTruthy();
+            animator = undefined;
+            await helpers_lib_1.UnitTestHelper.forceGarbageCollection();
+            (0, vitest_1.expect)(animator_1.Animator['_animatedObjects'].get(obj)).toBeTruthy();
+            (0, vitest_1.expect)(animator_1.Animator['_animatedObjects'].get(obj).has('x')).toBeFalsy();
+            (0, vitest_1.expect)(() => {
+                new animator_1.Animator(obj, 'x');
+            }).not.toThrow(`Animator: target property is already animated! Target: "{\n  "x": 0\n}", Property: "x"`);
+        });
+    });
+    (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');
+            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', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 0 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+            (0, vitest_1.expect)(animator.animating).toEqual(false);
+        });
+        (0, vitest_1.test)('animate to target in lineer', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 4 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(3);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('animate to target in easeInOut starting from zero', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.easeInOut,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 10 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(1.25);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(5);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(8.75);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(10);
+        });
+        (0, vitest_1.test)('animate to target in easeInOut starting from different value than zero', async () => {
+            let obj = { x: 10 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                animation: animations_1.Animations.easeInOut,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 20 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(11.25);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(15);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(18.75);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(20);
+        });
+        (0, vitest_1.test)('animate to target and return back', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 1,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 4 }).attachToRoot();
+            await skipTime();
+            animator.animate({ x: 0 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+        });
+        (0, vitest_1.test)('animateing an object with getter/setter property', async () => {
+            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,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 20 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(11.25);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(15);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(18.75);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(20);
+        });
+        (0, vitest_1.test)('animation event completion single property', async () => {
+            let completed = false;
+            let animator = new animator_1.Animator({ x: 0 }, 'x', {
+                duration: 2,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator
+                .animate({ x: 1 })
+                .tap(() => {
+                completed = true;
+            })
+                .attachToRoot();
+            (0, vitest_1.expect)(completed).toBeFalsy();
+            await skipTime();
+            (0, vitest_1.expect)(completed).toBeFalsy();
+            await skipTime();
+            (0, vitest_1.expect)(completed).toBeTruthy();
+        });
+        (0, vitest_1.test)('animation event completion multiple properties', async () => {
+            let completed1 = false;
+            let animator = new animator_1.Animator({ x: 0, y: 0 }, ['x', 'y'], {
+                duration: 2,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator
+                .animate({ x: 1, y: 1 })
+                .tap(() => {
+                completed1 = true;
+            })
+                .attachToRoot();
+            (0, vitest_1.expect)(completed1).toBeFalsy();
+            await skipTime();
+            (0, vitest_1.expect)(completed1).toBeFalsy();
+            await skipTime();
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+        });
+        (0, vitest_1.test)('animate multiple properties', async () => {
+            let obj = { x: 0, y: 10 };
+            let animator = new animator_1.Animator(obj, ['x', 'y'], {
+                duration: 4,
+                animation: animations_1.Animations.easeInOut,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            animator.animate({ x: 10, y: 0 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25, y: 8.75 });
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 5, y: 5 });
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75, y: 1.25 });
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 10, y: 0 });
+        });
+    });
+    (0, vitest_1.describe)('Set', () => {
+        (0, vitest_1.test)('it should change the original value', async () => {
+            let obj = { x: 0, y: 1, z: 2 };
+            let animator = new animator_1.Animator(obj, ['x', 'y', 'z']);
+            animator.set({ x: 3, y: 4, z: 5 });
+            (0, vitest_1.expect)(obj).toEqual({ x: 3, y: 4, z: 5 });
+        });
+    });
+    (0, vitest_1.describe)('Overriding Animator Options', () => {
+        (0, vitest_1.test)('animate to target with overriden duration', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer });
+            animator.animate({ x: 4 }, { duration: 2 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(2);
+        });
+        (0, vitest_1.test)('animate to target with overriden instant duration', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: animations_1.Animations.lineer });
+            animator.animate({ x: 4 }, { duration: 0 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('animate with custom values should override the default settings', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 10, animation: animations_1.Animations.lineer });
+            animator.animate({ x: 10 }, { duration: 4, animation: animations_1.Animations.easeInOut }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 1.25 });
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 5 });
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 8.75 });
+            await skipTime();
+            (0, vitest_1.expect)(obj).toEqual({ x: 10 });
+        });
+    });
+    (0, vitest_1.describe)('Subscribe', () => {
+        (0, vitest_1.test)('animate function triggering subscription callback', async () => {
+            let obj = { x: 0 };
+            let valueFromOnStep = 0;
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 4,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState,
+                animation: animations_1.Animations.easeInOut
+            });
+            animator.value
+                .subscribe(item => {
+                valueFromOnStep = item.x;
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            animator.animate({ x: 10 }).attachToRoot();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(0);
+            await skipTime();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(2);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(1.25);
+            await skipTime();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(3);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(5);
+            await skipTime();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(4);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(8.75);
+            await skipTime();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(5);
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(10);
+            await skipTime();
+            await skipTime();
+            await skipTime();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(5);
+        });
+        (0, vitest_1.test)('set function triggering subscription callback', async () => {
+            let obj = { x: 0 };
+            let valueFromOnStep = 0;
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x');
+            animator.value
+                .subscribe(item => {
+                valueFromOnStep = item.x;
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            animator.set({ x: 1 });
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(1);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(2);
+        });
+        (0, vitest_1.test)('animate subscribe should not be triggered on update if there is no ongoing animation', async () => {
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 4, animation: animations_1.Animations.easeInOut });
+            animator.value
+                .subscribe(() => {
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+        });
+        (0, vitest_1.test)('complete animations should not trigger subscription if it is not animating', async () => {
+            let triggerCount = 0;
+            let animator = new animator_1.Animator({ x: 0 }, 'x');
+            animator.value
+                .subscribe(() => {
+                triggerCount++;
+            })
+                .attachToRoot();
+            (0, vitest_1.expect)(triggerCount).toEqual(1);
+            animator.completeAnimation();
+            (0, vitest_1.expect)(triggerCount).toEqual(1);
+        });
+        (0, vitest_1.test)('complete animations should not trigger subscription if the value change is already triggered', async () => {
+            let obj = { x: 0 };
+            let heap = [];
+            let animator = new animator_1.Animator(obj, 'x', { duration: 2 });
+            animator.value.subscribe(value => heap.push(value.x)).attachToRoot();
+            animator.animate({ x: 1 }).attachToRoot();
+            await skipTime();
+            animator.completeAnimation();
+            (0, vitest_1.expect)(heap).toEqual([0, 0.5]);
+        });
+        (0, vitest_1.test)('subscription should not be called if no change happens via 0 time pass', async () => {
+            let obj = { x: 0 };
+            let valueFromOnStep = 0;
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x', { duration: 4 });
+            animator.value
+                .subscribe(item => {
+                valueFromOnStep = item.x;
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+            animator.animate({ x: 1 }).attachToRoot();
+            game_entities_1.UpdateCycle['_beforeSceneUpdateAction'].trigger({ time: 0, delta: 0 });
+            (0, vitest_1.expect)(valueFromOnStep).toEqual(0);
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+        });
+        (0, vitest_1.test)('set function should not trigger subscription if the value is the same', async () => {
+            let obj = { x: 0 };
+            let onStepCallCount = 0;
+            let animator = new animator_1.Animator(obj, 'x');
+            animator.value
+                .subscribe(() => {
+                onStepCallCount++;
+            })
+                .attachToRoot();
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+            animator.set({ x: 0 });
+            (0, vitest_1.expect)(onStepCallCount).toEqual(1);
+        });
+        (0, vitest_1.test)('subscribe should be called before the completion', async () => {
+            let heap = [];
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 1 });
+            animator.value
+                .subscribe(() => {
+                heap.push('subscribe');
+            })
+                .attachToRoot();
+            animator
+                .animate({ x: 1 })
+                .tap(() => heap.push('complete'))
+                .attachToRoot();
+            (0, vitest_1.expect)(heap).toEqual(['subscribe']);
+            await skipTime(1);
+            (0, vitest_1.expect)(heap).toEqual(['subscribe', 'subscribe', 'complete']);
+        });
+    });
+    (0, vitest_1.describe)('Re Animate Handling', () => {
+        (0, vitest_1.describe)('Throw Error', () => {
+            (0, vitest_1.test)('animate', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.ThrowError
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                (0, vitest_1.expect)(() => animator.animate({ x: 0 }).attachToRoot()).toThrow('Animator: new animation triggered while another is not complete yet.');
+                await skipTime();
+                (0, vitest_1.expect)(() => animator.animate({ x: 0 }).attachToRoot()).toThrow('Animator: new animation triggered while another is not complete yet.');
+                game_entities_1.UpdateCycle.triggerUpdateTick(3);
+                (0, vitest_1.expect)(() => animator.animate({ x: 0 }).attachToRoot()).not.toThrow('Animator: new animation triggered while another is not complete yet.');
+            });
+            (0, vitest_1.test)('set', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', { duration: 1, reAnimateHandling: animator_1.ReAnimateHandlingType.ThrowError });
+                animator.animate({ x: 1 }).attachToRoot();
+                animator.set({ x: 2 });
+                (0, vitest_1.expect)(obj.x).toEqual(2);
+            });
+        });
+        (0, vitest_1.describe)('Ignore New Animation', () => {
+            (0, vitest_1.test)('animate', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.IgnoreNewAnimation
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.animate({ x: 0 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.5);
+            });
+            (0, vitest_1.test)('set', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', { duration: 1, reAnimateHandling: animator_1.ReAnimateHandlingType.IgnoreNewAnimation });
+                animator.animate({ x: 1 }).attachToRoot();
+                animator.set({ x: 2 });
+                (0, vitest_1.expect)(obj.x).toEqual(2);
+            });
+        });
+        (0, vitest_1.describe)('Complete Previous', () => {
+            (0, vitest_1.test)('return to original', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.animate({ x: 2 }).attachToRoot();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.5);
+            });
+            (0, vitest_1.test)('stay in current', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.animate({ x: 1.25 }).attachToRoot();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.5);
+            });
+            (0, vitest_1.test)('jump to end', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.animate({ x: 0 }).attachToRoot();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.75);
+            });
+            (0, vitest_1.test)('loop', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.Loop
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.animate({ x: 2 }).attachToRoot();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.5);
+            });
+            (0, vitest_1.test)('set', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious
+                });
+                animator.animate({ x: 4 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                animator.set({ x: 1 });
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+            });
+        });
+    });
+    (0, vitest_1.describe)('Complete Animation Handling', () => {
+        (0, vitest_1.describe)('Return To Original', () => {
+            (0, vitest_1.test)('animate', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 1,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+                });
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+            });
+            (0, vitest_1.test)('subscription', async () => {
+                let obj = { x: 0 };
+                let heap = [];
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+                });
+                animator.value.subscribe(value => heap.push(value.x)).attachToRoot();
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                heap = [];
+                animator.completeAnimation();
+                (0, vitest_1.expect)(heap).toEqual([0]);
+            });
+            (0, vitest_1.test)('complete animations function', async () => {
+                let obj = { x: 0 };
+                let completed = false;
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+                });
+                animator
+                    .animate({ x: 1 })
+                    .tap(() => {
+                    completed = true;
+                })
+                    .attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(completed).toBeFalsy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.completeAnimation();
+                (0, vitest_1.expect)(completed).toBeTruthy();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+            });
+            (0, vitest_1.test)('destroying', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+                });
+                let animation = animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                (0, vitest_1.expect)(animator.animating).toBeTruthy();
+                animation.destroy();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+            });
+        });
+        (0, vitest_1.describe)('Stay In Current State', () => {
+            (0, vitest_1.test)('animate', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x');
+                animator
+                    .animate({ x: 4 }, {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+                })
+                    .attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                animator.completeAnimation();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+            });
+            (0, vitest_1.test)('subscription', async () => {
+                let obj = { x: 0 };
+                let heap = [];
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+                });
+                animator.value.subscribe(value => heap.push(value.x)).attachToRoot();
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                heap = [];
+                animator.completeAnimation();
+                // should not be triggered when staying in the current state
+                (0, vitest_1.expect)(heap).toEqual([]);
+            });
+            (0, vitest_1.test)('complete animations function', async () => {
+                let obj = { x: 0 };
+                let completed = false;
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+                });
+                animator
+                    .animate({ x: 1 })
+                    .tap(() => {
+                    completed = true;
+                })
+                    .attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(completed).toBeFalsy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.completeAnimation();
+                (0, vitest_1.expect)(completed).toBeTruthy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+            });
+            (0, vitest_1.test)('destroying', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+                });
+                let animation = animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                (0, vitest_1.expect)(animator.animating).toBeTruthy();
+                animation.destroy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+            });
+        });
+        (0, vitest_1.describe)('Jump To End', () => {
+            (0, vitest_1.test)('animate', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x');
+                animator
+                    .animate({ x: 4 }, {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd
+                })
+                    .attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                animator.completeAnimation();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(4);
+            });
+            (0, vitest_1.test)('subscription', async () => {
+                let obj = { x: 0 };
+                let heap = [];
+                let animator = new animator_1.Animator(obj, 'x', { duration: 4, completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd });
+                animator.value.subscribe(value => heap.push(value.x)).attachToRoot();
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                heap = [];
+                animator.completeAnimation();
+                (0, vitest_1.expect)(heap).toEqual([1]);
+            });
+            (0, vitest_1.test)('complete animations function', async () => {
+                let obj = { x: 0 };
+                let completed = false;
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd
+                });
+                animator
+                    .animate({ x: 1 })
+                    .tap(() => {
+                    completed = true;
+                })
+                    .attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(completed).toBeFalsy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                animator.completeAnimation();
+                (0, vitest_1.expect)(completed).toBeTruthy();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+            });
+            (0, vitest_1.test)('destroying', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd
+                });
+                let animation = animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                (0, vitest_1.expect)(animator.animating).toBeTruthy();
+                animation.destroy();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+            });
+        });
+        (0, vitest_1.describe)('Loop', () => {
+            (0, vitest_1.test)('animate', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.easeInOut,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.Loop
+                });
+                animator.animate({ x: 10 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 1.25 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 5 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 8.75 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 0 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 1.25 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 5 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 8.75 });
+                await skipTime();
+                (0, vitest_1.expect)(obj).toEqual({ x: 0 });
+            });
+            (0, vitest_1.test)('subscription', async () => {
+                let obj = { x: 0 };
+                let heap = [];
+                let animator = new animator_1.Animator(obj, 'x', { duration: 4, completionHandling: animator_1.AnimationsCompletionHandlingType.Loop });
+                animator.value.subscribe(value => heap.push(value.x)).attachToRoot();
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                heap = [];
+                animator.completeAnimation();
+                (0, vitest_1.expect)(heap).toEqual([0]);
+            });
+            (0, vitest_1.test)('complete animations function', async () => {
+                let obj = { x: 0 };
+                let completed = false;
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 2,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.Loop
+                });
+                animator
+                    .animate({ x: 1 })
+                    .tap(() => {
+                    completed = true;
+                })
+                    .attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(completed).toBeFalsy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.5);
+                await skipTime();
+                (0, vitest_1.expect)(completed).toBeFalsy();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                await skipTime();
+                (0, vitest_1.expect)(completed).toBeFalsy();
+                (0, vitest_1.expect)(obj.x).toEqual(0.5);
+                animator.completeAnimation();
+                (0, vitest_1.expect)(completed).toBeTruthy();
+                (0, vitest_1.expect)(obj.x).toEqual(0); // loop always returns to original after it ends, during the loop or on complete animations
+            });
+            (0, vitest_1.test)('animate should still take action if the target value is the same', async () => {
+                let obj = { x: 1 };
+                let animator = new animator_1.Animator(obj, 'x', { duration: 4, completionHandling: animator_1.AnimationsCompletionHandlingType.Loop });
+                let triggered = false;
+                animator.value
+                    .subscribe(() => {
+                    triggered = true;
+                })
+                    .attachToRoot();
+                animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(1);
+                (0, vitest_1.expect)(animator.animating).toEqual(true);
+                (0, vitest_1.expect)(triggered).toBeTruthy();
+            });
+            (0, vitest_1.test)('destroying', async () => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 4,
+                    animation: animations_1.Animations.lineer,
+                    completionHandling: animator_1.AnimationsCompletionHandlingType.Loop
+                });
+                let animation = animator.animate({ x: 1 }).attachToRoot();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0.25);
+                (0, vitest_1.expect)(animator.animating).toBeTruthy();
+                animation.destroy();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+                await skipTime();
+                (0, vitest_1.expect)(obj.x).toEqual(0);
+                (0, vitest_1.expect)(animator.animating).toBeFalsy();
+            });
+        });
+    });
+    (0, vitest_1.describe)('Overriding Options', () => {
+        (0, vitest_1.test)('complete animations options overriden in animate', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+            });
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd
+            })
+                .attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimation();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(4);
+        });
+        (0, vitest_1.test)('complete animations options overriden in complete animations', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+            });
+            animator
+                .animate({ x: 4 }, {
+                duration: 4,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.JumpToEnd
+            })
+                .attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            animator.completeAnimation(animator_1.AnimationsCompletionHandlingType.StayInCurrentState);
+            await skipTime();
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+        });
+    });
+    (0, vitest_1.describe)('Animating Property', () => {
+        (0, vitest_1.test)('animating should be true if it is animating', async () => {
+            let animator = new animator_1.Animator({ x: 0 }, 'x', { duration: 1, animation: animations_1.Animations.lineer });
+            animator.animate({ x: 1 }).attachToRoot();
+            (0, vitest_1.expect)(animator.animating).toBeTruthy();
+        });
+        (0, vitest_1.test)('animating should be false if it is not animating', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: animations_1.Animations.lineer });
+            (0, vitest_1.expect)(animator.animating).toBeFalsy();
+            animator.animate({ x: 1 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(animator.animating).toBeFalsy();
+        });
+    });
+    (0, vitest_1.describe)('Edge Cases', () => {
+        (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();
+            let animator = new animator_1.Animator(object, 'scale', {
+                duration: 4,
+                reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            let completed1 = false;
+            let completed2 = false;
+            animator
+                .animate({ scale: 2 })
+                .tap(() => {
+                completed1 = true;
+                object.destroy();
+            })
+                .attach(object);
+            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,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            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();
+            })
+                .attach(object);
+            await skipTime();
+            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();
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(animation1Complete).toBeTruthy();
+            (0, vitest_1.expect)(completed1).toBeTruthy();
+            (0, vitest_1.expect)(completed2).toBeTruthy();
+        });
+        (0, vitest_1.test)('time passes more than the animation duration when completion is in loop', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 1,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.Loop
+            });
+            animator.animate({ x: 1 }).attachToRoot();
+            await skipTime(10);
+            (0, vitest_1.expect)(obj.x).toEqual(0);
+            await skipTime(10.5);
+            (0, vitest_1.expect)(obj.x).toEqual(0.5);
+        });
+        (0, vitest_1.test)('animation chain waiting for another async event should not delay unsubcription', async () => {
+            let obj = { x: 0 };
+            let action = new actions_lib_1.Action();
+            let animator = new animator_1.Animator(obj, 'x', {
+                duration: 2,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+            });
+            let triggered = false;
+            animator
+                .animate({ x: 1 })
+                .asyncMap(() => action)
+                .tap(() => {
+                triggered = true;
+            })
+                .attachToRoot();
+            await skipTime(2);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            await skipTime(1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+            (0, vitest_1.expect)(triggered).toBeFalsy();
+            action.trigger();
+            (0, vitest_1.expect)(triggered).toBeTruthy();
+            await skipTime(1);
+            (0, vitest_1.expect)(obj.x).toEqual(1);
+        });
+        (0, vitest_1.test)('if target is destroyed, the animator should skip the completion handling', 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,
+                animation: animations_1.Animations.lineer,
+                completionHandling: animator_1.AnimationsCompletionHandlingType.ReturnToOriginal
+            });
+            let animation = animator.animate({ scale: 2 }).attachToRoot();
+            await skipTime();
+            (0, vitest_1.expect)(object.scale).toEqual(1.25);
+            object.destroy();
+            (0, vitest_1.expect)(object.destroyed).toBeTruthy();
+            animation.destroy();
+            (0, vitest_1.expect)(object.scale).toEqual(1.25);
+        });
+    });
+});
+//# sourceMappingURL=animator.test.js.map