bard-legends-framework 0.11.0 → 0.12.1

package/dist/utilities/animator/animator.d.ts

@@ -1,4 +1,4 @@
-import { Attachable } from 'actions-lib';
+import { Attachable, SingleEvent } from 'actions-lib';
 import { AnimatorAnimation } from './animations';
 export interface AnimationState {
     duration: number;
@@ -39,7 +39,6 @@ export declare class Animator<T> extends Attachable {
     private running;
     private propertyStates;
     private updateCycleSubscription;
-    private allResolvers;
     get isAnimating(): boolean;
     constructor(target: T, effectOn: string | string[], options?: AnimationOptions);
     onChange(callback: (target: T) => void): Animator<T>;
@@ -50,7 +49,7 @@ export declare class Animator<T> extends Attachable {
     resumeAnimations(): void;
     completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
     set(values: Record<string, any>): void;
-    animate(values: Record<string, any>, options?: AnimationOptions): Promise<void>;
+    animate(values: Record<string, any>, options?: AnimationOptions): SingleEvent;
     private completeAnimationOfProperty;
     private checkOngoingAnimations;
     private update;

package/dist/utilities/animator/animator.js

@@ -33,7 +33,6 @@ class Animator extends actions_lib_1.Attachable {
         this.effectOn = new Set();
         this.running = true;
         this.propertyStates = new Map();
-        this.allResolvers = new Set();
         if (!helpers_lib_1.Comparator.isObject(target)) {
             this.attachToRoot();
             throw new Error(`Animator: target is not an object! Target: "${target}"`);
@@ -44,19 +43,19 @@ class Animator extends actions_lib_1.Attachable {
             animatedObjectProperties = new Set();
             Animator.animatedObjects.set(target, animatedObjectProperties);
         }
-        this.effectOn.forEach(key => {
+        for (let key of this.effectOn) {
             if (animatedObjectProperties.has(key)) {
                 this.attachToRoot();
                 throw new Error(`Animator: target property is already animated! Target: "${JSON.stringify(target, undefined, 2)}", Property: "${key}"`);
             }
             animatedObjectProperties.add(key);
-        });
+        }
         this.defaultDuration = options.duration ?? DEFAULT_DURATION;
         this.defaultAnimation = options.animation ?? DEFAULT_ANIMATION;
         this.defaultLoop = options.loop ?? DEFAULT_LOOP;
         this.defaultReAnimateHandling = options.reAnimateHandling ?? DEFAULT_RE_ANIMATE_HANDLING;
         this.defaultCompleteAnimationsHandling = options.completeAnimationsHandling ?? DEFAULT_COMPLETE_ANIMATIONS_HANDLING;
-        this.effectOn.forEach(key => {
+        for (let key of this.effectOn) {
             if (!helpers_lib_1.Comparator.hasProperty(target, key)) {
                 this.attachToRoot();
                 throw new Error(`Animator: target does not have property. Target property: "${key}"`);
@@ -65,7 +64,7 @@ class Animator extends actions_lib_1.Attachable {
                 this.attachToRoot();
                 throw new Error(`Animator: target property is not a number. Target property: "${key}"`);
             }
-        });
+        }
     }
     onChange(callback) {
         if (this.onChangeCallback) {
@@ -90,13 +89,13 @@ class Animator extends actions_lib_1.Attachable {
             this.defaultAnimation = DEFAULT_ANIMATION;
             this.propertyStates.clear();
             let animatedObjectProperties = Animator.animatedObjects.get(this.target);
-            this.effectOn.forEach(key => animatedObjectProperties.delete(key));
+            for (let key of this.effectOn) {
+                animatedObjectProperties.delete(key);
+            }
             if (animatedObjectProperties.size <= 0) {
                 Animator.animatedObjects.delete(this.target);
             }
             this.target = undefined;
-            this.allResolvers.forEach(resolver => resolver());
-            this.allResolvers.clear();
             super.destroy();
         }
     }
@@ -121,7 +120,7 @@ class Animator extends actions_lib_1.Attachable {
     }
     completeAnimations(completeAnimationsHandling) {
         let triggerOnChange = false;
-        this.propertyStates.forEach((value, key) => {
+        for (let [key, value] of this.propertyStates) {
             let completeAnimationsHandlingFinal = completeAnimationsHandling ?? value.completeAnimationsHandling;
             if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
                 if (this.target[key] !== value.startingValue) {
@@ -136,33 +135,46 @@ class Animator extends actions_lib_1.Attachable {
                 }
             }
             this.completeAnimationOfProperty(value);
-        });
+        }
         triggerOnChange && this.triggerOnChange();
     }
     set(values) {
-        Object.keys(values).forEach(key => {
-            this.checkPropertyValidity(key);
-        });
+        let keys = Object.keys(values);
+        for (let i = 0; i < keys.length; i++) {
+            this.checkPropertyValidity(keys[i]);
+        }
         this.checkOngoingAnimations(values);
         let triggerOnChange = false;
-        Object.keys(values).forEach(key => {
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
             triggerOnChange = triggerOnChange || this.target[key] !== values[key];
             this.target[key] = values[key];
-        });
+        }
         triggerOnChange && this.triggerOnChange();
     }
-    async animate(values, options = {}) {
+    animate(values, options = {}) {
         if (this.destroyed) {
-            return;
+            return actions_lib_1.SingleEvent.create(resolve => resolve());
         }
         let valueKeys = Object.keys(values);
-        valueKeys.forEach(key => {
-            this.checkPropertyValidity(key);
-        });
+        for (let i = 0; i < valueKeys.length; i++) {
+            this.checkPropertyValidity(valueKeys[i]);
+        }
         this.checkOngoingAnimations(values, options.reAnimateHandling);
-        return new Promise(resolveAll => {
-            this.allResolvers.add(resolveAll);
-            Promise.all(Object.keys(values).map(key => new Promise(resolve => {
+        // Recalculate valueKeys after checkOngoingAnimations, as it may have deleted some keys
+        valueKeys = Object.keys(values);
+        this.subscribeUpdateCycle();
+        return actions_lib_1.SingleEvent.create(resolve => {
+            let ongoingKeys = new Set(valueKeys);
+            let animationDone = (key) => {
+                ongoingKeys.delete(key);
+                if (ongoingKeys.size <= 0) {
+                    resolve();
+                }
+            };
+            // console.log(Object.keys(values), ongoingKeys);
+            for (let i = 0; i < valueKeys.length; i++) {
+                let key = valueKeys[i];
                 let duration = options.duration ?? this.defaultDuration;
                 let animation = options.animation ?? this.defaultAnimation;
                 let loop = options.loop ?? this.defaultLoop;
@@ -170,34 +182,28 @@ class Animator extends actions_lib_1.Attachable {
                 let startingValue = this.target[key];
                 let targetValue = values[key];
                 if (startingValue === targetValue && !loop) {
-                    resolve(undefined);
-                    return;
+                    animationDone(key);
                 }
-                animation.start();
-                try {
-                    this.propertyStates.set(key, {
-                        propertyName: key,
-                        duration,
-                        animation,
-                        elapsedTime: 0,
-                        startingValue,
-                        targetValue,
-                        loop,
-                        completeAnimationsHandling,
-                        completionCallback: () => {
-                            resolve(undefined);
-                        }
-                    });
-                }
-                catch {
-                    resolveAll();
-                    this.allResolvers.delete(resolveAll);
+                else {
+                    animation.start();
+                    try {
+                        this.propertyStates.set(key, {
+                            propertyName: key,
+                            duration,
+                            animation,
+                            elapsedTime: 0,
+                            startingValue,
+                            targetValue,
+                            loop,
+                            completeAnimationsHandling,
+                            completionCallback: () => animationDone(key)
+                        });
+                    }
+                    catch {
+                        animationDone(key);
+                    }
                 }
-            }))).then(() => {
-                resolveAll();
-                this.allResolvers.delete(resolveAll);
-            });
-            this.subscribeUpdateCycle();
+            }
         });
     }
     completeAnimationOfProperty(propertyState) {
@@ -213,11 +219,12 @@ class Animator extends actions_lib_1.Attachable {
     }
     checkOngoingAnimations(values, reAnimateHandling) {
         reAnimateHandling = reAnimateHandling ?? this.defaultReAnimateHandling;
-        Object.keys(values).forEach(key => {
+        let keys = Object.keys(values);
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
             let previousState = this.propertyStates.get(key);
             if (previousState) {
                 if (reAnimateHandling === ReAnimateHandlingType.throwError) {
-                    this.attachToRoot();
                     throw new Error(`Animator: property is already being animated. Property: "${key}"`);
                 }
                 else if (reAnimateHandling === ReAnimateHandlingType.ignoreNewAnimation) {
@@ -227,13 +234,13 @@ class Animator extends actions_lib_1.Attachable {
                     this.completeAnimationOfProperty(previousState);
                 }
             }
-        });
+        }
     }
     update(delta) {
         if (this.running && !this.destroyed) {
             let triggerOnChange = this.propertyStates.size;
             let propertyStatesToComplete = [];
-            this.propertyStates.forEach((value, key) => {
+            for (let [key, value] of this.propertyStates) {
                 value.elapsedTime += delta;
                 let animationIsCompete = value.elapsedTime >= value.duration;
                 if (animationIsCompete) {
@@ -249,7 +256,7 @@ class Animator extends actions_lib_1.Attachable {
                         else {
                             this.target[key] = value.targetValue;
                         }
-                        // Do not complete inside the forEach loop, completion can start a new animation which will put forEach into infinite loop
+                        // Do not complete inside the for loop, completion can start a new animation which will put the loop into infinite loop
                         propertyStatesToComplete.push(value);
                     }
                 }
@@ -258,10 +265,10 @@ class Animator extends actions_lib_1.Attachable {
                     let relativeTarget = value.targetValue - value.startingValue;
                     this.target[key] = relativeTarget * multiplier + value.startingValue;
                 }
-            });
-            propertyStatesToComplete.forEach(value => {
+            }
+            for (let value of propertyStatesToComplete) {
                 this.completeAnimationOfProperty(value);
-            });
+            }
             triggerOnChange && this.triggerOnChange();
             if (this.propertyStates.size <= 0) {
                 this.unsubscribeUpdateCycle();
@@ -277,14 +284,14 @@ class Animator extends actions_lib_1.Attachable {
                 }
                 catch (e) {
                     console.error('Animator:', e);
-                    this.propertyStates.forEach(value => {
+                    for (let value of this.propertyStates.values()) {
                         try {
                             value.completionCallback();
                         }
                         catch (err) {
                             console.error('Animator:', err);
                         }
-                    });
+                    }
                     this.propertyStates = new Map();
                     this.unsubscribeUpdateCycle();
                 }

package/dist/utilities/animator/animator.performance.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const animator_1 = require("./animator");
+vitest_1.describe.skipIf(!process.env.MANUAL)('Performance Tests', () => {
+    (0, vitest_1.test)('single', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 1
+                }).attachToRoot();
+                animator.animate({ x: 1 }).tap(resolve).attachToRoot();
+                animator['update'](1);
+            });
+            // 3.178299903869629
+            // converting to single event: 6.434300422668457
+            // with wait until all destroyed: 11.552299976348877
+            // 7.839200019836426
+            // last comparible: 5.697200298309326
+            // no forEach: 5.479100227355957
+            // after bundle: 2.5292000770568848
+        }, { sampleCount: 200 });
+    }, 60000);
+    (0, vitest_1.test)('multiple', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, ['x', 'y'], {
+                    duration: 1
+                }).attachToRoot();
+                animator.animate({ x: 1, y: 1 }).tap(resolve).attachToRoot();
+                animator['update'](1);
+            });
+            // 3.6912999153137207
+            // converting to single event: 6.845600128173828
+            // with wait until all destroyed: 13.253100395202637
+            // 9.115399837493896
+            // last comparible: 6.0391998291015625
+            // no forEach: 5.958700180053711
+            // after bundle: 2.9321999549865723
+        }, { sampleCount: 200 });
+    }, 60000);
+});
+//# sourceMappingURL=animator.performance.test.js.map

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

@@ -204,9 +204,12 @@ const animator_1 = require("./animator");
             let obj = { x: 0 };
             let completed = false;
             let animator = new animator_1.Animator(obj, 'x').attachToRoot();
-            animator.animate({ x: 1 }, { duration: 2 }).then(() => {
+            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();
@@ -311,9 +314,11 @@ const animator_1 = require("./animator");
                 reAnimateHandling: animator_1.ReAnimateHandlingType.throwError
             }).attachToRoot();
             animator.animate({ x: 1 });
-            await (0, vitest_1.expect)(animator.animate({ x: 0 })).rejects.toThrow();
+            (0, vitest_1.expect)(() => animator.animate({ x: 0 })).toThrow('Animator: property is already being animated. Property: "x"');
             animator['update'](1);
-            await (0, vitest_1.expect)(animator.animate({ x: 0 })).rejects.toThrow();
+            (0, vitest_1.expect)(() => animator.animate({ x: 0 })).toThrow('Animator: property is already being animated. Property: "x"');
+            animator['update'](3);
+            (0, vitest_1.expect)(() => animator.animate({ x: 0 })).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 };
@@ -484,9 +489,12 @@ const animator_1 = require("./animator");
             let obj = { x: 0 };
             let completed = false;
             let animator = new animator_1.Animator(obj, 'x').attachToRoot();
-            animator.animate({ x: 1 }, { duration: 4 }).then(() => {
+            animator
+                .animate({ x: 1 }, { duration: 4 })
+                .tap(() => {
                 completed = true;
-            });
+            })
+                .attachToRoot();
             animator['update'](1);
             await (0, helpers_lib_1.Wait)();
             (0, vitest_1.expect)(completed).toBeFalsy();
@@ -499,13 +507,19 @@ const animator_1 = require("./animator");
             let completed2 = false;
             let obj = { x: 0, y: 0 };
             let animator = new animator_1.Animator(obj, ['x', 'y'], { duration: 4, animation: new animations_1.AnimationEaseInOut() }).attachToRoot();
-            animator.animate({ y: 10 }, { loop: true }).then(() => {
+            animator
+                .animate({ y: 10 }, { loop: true })
+                .tap(() => {
                 completed1 = true;
-            });
+            })
+                .attachToRoot();
             animator['update'](1);
-            animator.animate({ x: 10 }).then(() => {
+            animator
+                .animate({ x: 10 })
+                .tap(() => {
                 completed2 = true;
-            });
+            })
+                .attachToRoot();
             animator['update'](1);
             await (0, helpers_lib_1.Wait)();
             (0, vitest_1.expect)(completed1).toBeFalsy();
@@ -784,13 +798,19 @@ const animator_1 = require("./animator");
             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 }).then(() => {
+            animator
+                .animate({ y: 10 })
+                .tap(() => {
                 completed1 = true;
-            });
+            })
+                .attachToRoot();
             animator['update'](1);
-            animator.animate({ x: 10 }).then(() => {
+            animator
+                .animate({ x: 10 })
+                .tap(() => {
                 completed2 = true;
-            });
+            })
+                .attachToRoot();
             animator['update'](2);
             await (0, helpers_lib_1.Wait)();
             (0, vitest_1.expect)(completed1).toBeFalsy();
@@ -833,13 +853,13 @@ const animator_1 = require("./animator");
             let obj = { x: 0 };
             let animator = new animator_1.Animator(obj, 'x', { duration: 4, animation: new animations_1.AnimationLineer() }).attachToRoot();
             animator.animate({ x: 4 });
-            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
             (0, vitest_1.expect)(obj.x).toEqual(1);
-            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
             (0, vitest_1.expect)(obj.x).toEqual(2);
-            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
             (0, vitest_1.expect)(obj.x).toEqual(3);
-            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
             (0, vitest_1.expect)(obj.x).toEqual(4);
         });
     });
@@ -848,19 +868,60 @@ const animator_1 = require("./animator");
             let obj = { x: 0 };
             let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: new animations_1.AnimationLineer() }).attachToRoot();
             animator.destroy();
-            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
             animator.animate({ x: 1 });
-            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
             (0, vitest_1.expect)(obj.x).toEqual(0);
         });
-        (0, vitest_1.test)('destroyed animators animation promises should not get stuck', async () => {
-            return new Promise(done => {
-                let obj = { x: 0 };
-                let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: new animations_1.AnimationLineer() }).attachToRoot();
-                let promise = animator.animate({ x: 1 });
-                animator.destroy();
-                promise.then(() => done());
-            });
+        (0, vitest_1.test)('after destroy animation should not trigger complete', async () => {
+            let obj = { x: 0 };
+            let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: new animations_1.AnimationLineer() }).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: new animations_1.AnimationLineer() }).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: new animations_1.AnimationLineer() }).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();
         });
     });
 });

package/dist/utilities/animator/animator2/animator.d.ts

@@ -0,0 +1,42 @@
+import { IAttachment, NotifierCallbackFunction, SingleEvent } from 'actions-lib';
+import { AnimatorAnimation } from '../animations';
+export declare enum ReAnimateHandlingType {
+    throwError = 1,
+    ignoreNewAnimation = 2,
+    completePrevious = 3
+}
+export declare enum AnimationsCompletionHandlingType {
+    returnToOriginal = 1,
+    stayInCurrentState = 2,
+    jumpToEnd = 3,
+    loop = 4
+}
+export interface AnimationOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly reAnimateHandling: ReAnimateHandlingType;
+    readonly completionHandling: AnimationsCompletionHandlingType;
+}
+type NumericKeys<T> = {
+    [P in keyof T]: T[P] extends number ? P : never;
+}[keyof T] & string;
+export declare class Animator<T extends object = any, K extends NumericKeys<T> = NumericKeys<T>> {
+    private static _animatedObjects;
+    private static _getAnimatedObjectProperties;
+    private _target;
+    private _options;
+    private _animatedProperties;
+    private _subscribeCallback?;
+    private _ongoingAnimation;
+    get animating(): boolean;
+    constructor(target: T & Record<K, number>, animatedProperties: K | K[], partialOptions?: Partial<AnimationOptions>);
+    subscribe(callback: NotifierCallbackFunction<T>): IAttachment;
+    animate(values: Record<K, number>, partialOptions?: Partial<AnimationOptions>): SingleEvent<void>;
+    set(values: Record<K, number>): void;
+    completeAnimation(completionHandling?: AnimationsCompletionHandlingType): void;
+    private _isAnimatingToSameValues;
+    private _setCompletionValues;
+    private _setValues;
+    private _lockAnimatedProperties;
+}
+export {};