bard-legends-framework 0.10.9 → 0.12.0

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 {};

package/dist/utilities/animator/animator2/animator.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animator = exports.AnimationsCompletionHandlingType = exports.ReAnimateHandlingType = void 0;
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const game_entities_1 = require("../../../game-entities");
+const animations_1 = require("../animations");
+var ReAnimateHandlingType;
+(function (ReAnimateHandlingType) {
+    ReAnimateHandlingType[ReAnimateHandlingType["throwError"] = 1] = "throwError";
+    ReAnimateHandlingType[ReAnimateHandlingType["ignoreNewAnimation"] = 2] = "ignoreNewAnimation";
+    ReAnimateHandlingType[ReAnimateHandlingType["completePrevious"] = 3] = "completePrevious";
+})(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
+var AnimationsCompletionHandlingType;
+(function (AnimationsCompletionHandlingType) {
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["returnToOriginal"] = 1] = "returnToOriginal";
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["stayInCurrentState"] = 2] = "stayInCurrentState";
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["jumpToEnd"] = 3] = "jumpToEnd";
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["loop"] = 4] = "loop";
+})(AnimationsCompletionHandlingType || (exports.AnimationsCompletionHandlingType = AnimationsCompletionHandlingType = {}));
+class Animator {
+    static { this._animatedObjects = new WeakMap(); }
+    static _getAnimatedObjectProperties(target) {
+        let animatedObjectProperties = Animator._animatedObjects.get(target);
+        if (!animatedObjectProperties) {
+            animatedObjectProperties = new helpers_lib_1.MapToWeakRefs();
+            Animator._animatedObjects.set(target, animatedObjectProperties);
+        }
+        return animatedObjectProperties;
+    }
+    get animating() {
+        return this._ongoingAnimation !== undefined;
+    }
+    constructor(target, animatedProperties, partialOptions) {
+        this._target = target;
+        this._options = {
+            duration: 200,
+            animation: animations_1.Animations.lineer,
+            reAnimateHandling: ReAnimateHandlingType.throwError,
+            completionHandling: AnimationsCompletionHandlingType.stayInCurrentState,
+            ...partialOptions
+        };
+        this._animatedProperties = helpers_lib_1.Comparator.isArray(animatedProperties) ? animatedProperties : [animatedProperties];
+        this._lockAnimatedProperties(target, this._animatedProperties); // NOTE: this can be removed in release mode
+    }
+    subscribe(callback) {
+        if (this._subscribeCallback) {
+            throw new Error('Animator: subscribe is already set, there should be max one subscriber by design.');
+        }
+        this._subscribeCallback = callback;
+        return new actions_lib_1.ActionSubscription(() => {
+            this._subscribeCallback = undefined;
+        });
+    }
+    animate(values, partialOptions) {
+        let options = {
+            ...this._options,
+            ...partialOptions
+        };
+        if (this._ongoingAnimation) {
+            switch (options.reAnimateHandling) {
+                case ReAnimateHandlingType.throwError:
+                    throw new Error(`Animator: new animation triggered while another is not complete yet.`);
+                case ReAnimateHandlingType.ignoreNewAnimation:
+                    return actions_lib_1.SingleEvent.instant();
+                case ReAnimateHandlingType.completePrevious:
+                    this._setCompletionValues(options.completionHandling, this._ongoingAnimation._propertyStartingValues, this._ongoingAnimation._propertyTargetValues, true);
+                    break;
+                default: {
+                    let _ = options.reAnimateHandling;
+                    throw new Error(`Animator: unknown re-animate handling type: "${options.reAnimateHandling}"`);
+                }
+            }
+        }
+        let event = actions_lib_1.SingleEvent.create((resolve, context) => {
+            let updateCycleSubscription;
+            let animationState = {
+                _duration: options.duration,
+                _elapsedTime: 0,
+                _propertyStartingValues: this._animatedProperties.reduce((acc, key) => {
+                    acc[key] = this._target[key];
+                    return acc;
+                }, {}),
+                _propertyTargetValues: this._animatedProperties.reduce((acc, key) => {
+                    acc[key] = values[key];
+                    return acc;
+                }, {}),
+                _completionHandling: options.completionHandling,
+                _animation: options.animation,
+                _completionCallback: resolve
+            };
+            if (animationState._completionHandling !== AnimationsCompletionHandlingType.loop &&
+                this._isAnimatingToSameValues(animationState)) {
+                this._ongoingAnimation = undefined;
+                resolve();
+                return;
+            }
+            else {
+                animationState._animation.start();
+            }
+            let previousAnimationState = this._ongoingAnimation;
+            this._ongoingAnimation = animationState;
+            updateCycleSubscription = game_entities_1.UpdateCycle.beforeSceneUpdateAction
+                .subscribe(update => {
+                animationState._elapsedTime += update.delta;
+                let animationIsCompete = animationState._elapsedTime >= animationState._duration;
+                if (animationIsCompete) {
+                    if (animationState._completionHandling === AnimationsCompletionHandlingType.loop) {
+                        animationState._elapsedTime %= animationState._duration;
+                        animationState._animation.start();
+                        animationIsCompete = false;
+                    }
+                    else {
+                        this._setCompletionValues(animationState._completionHandling, animationState._propertyStartingValues, animationState._propertyTargetValues, false);
+                        this._ongoingAnimation = undefined;
+                        animationState._completionCallback();
+                    }
+                }
+                if (!animationIsCompete) {
+                    let multiplier = animationState._animation.multiplierFunction(animationState._elapsedTime / animationState._duration);
+                    let changeHappened = false;
+                    for (let i = 0; i < this._animatedProperties.length; i++) {
+                        let key = this._animatedProperties[i];
+                        let propertyStartingValue = animationState._propertyStartingValues[key];
+                        let propertyTargetValue = animationState._propertyTargetValues[key];
+                        let relativeTarget = propertyTargetValue - propertyStartingValue;
+                        let newValue = relativeTarget * multiplier + propertyStartingValue;
+                        if (newValue !== this._target[key]) {
+                            changeHappened = true;
+                            this._target[key] = newValue;
+                        }
+                    }
+                    changeHappened && this._subscribeCallback?.(this._target);
+                }
+            })
+                .attach(context.attachable);
+            previousAnimationState?._completionCallback();
+            return () => {
+                if (this._ongoingAnimation === animationState) {
+                    updateCycleSubscription.destroy();
+                    this._setCompletionValues(this._ongoingAnimation._completionHandling, this._ongoingAnimation._propertyStartingValues, this._ongoingAnimation._propertyTargetValues, true);
+                    this._ongoingAnimation = undefined;
+                }
+            };
+        });
+        return event;
+    }
+    set(values) {
+        let changeHappened = false;
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== values[key]) {
+                changeHappened = true;
+                this._target[key] = values[key];
+            }
+        }
+        changeHappened && this._subscribeCallback?.(this._target);
+        this._ongoingAnimation?._completionCallback();
+    }
+    completeAnimation(completionHandling) {
+        if (this._ongoingAnimation) {
+            completionHandling = completionHandling ?? this._ongoingAnimation._completionHandling;
+            this._setCompletionValues(completionHandling, this._ongoingAnimation._propertyStartingValues, this._ongoingAnimation._propertyTargetValues, true);
+            let callback = this._ongoingAnimation._completionCallback;
+            this._ongoingAnimation = undefined;
+            callback();
+        }
+    }
+    _isAnimatingToSameValues(ongoingAnimation) {
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== ongoingAnimation._propertyTargetValues[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _setCompletionValues(completionHandling, startingValues, targetValues, interruptedCompletion) {
+        switch (completionHandling) {
+            case AnimationsCompletionHandlingType.returnToOriginal:
+                this._setValues(startingValues);
+                break;
+            case AnimationsCompletionHandlingType.stayInCurrentState:
+                if (!interruptedCompletion) {
+                    this._setValues(targetValues);
+                }
+                break;
+            case AnimationsCompletionHandlingType.jumpToEnd:
+                this._setValues(targetValues);
+                break;
+            case AnimationsCompletionHandlingType.loop:
+                this._setValues(startingValues);
+                break;
+            default: {
+                let _ = completionHandling;
+                throw new Error(`Animator: unknown completion handling type: "${completionHandling}"`);
+            }
+        }
+    }
+    _setValues(values) {
+        let changeHappened = false;
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== values[key]) {
+                changeHappened = true;
+                this._target[key] = values[key];
+            }
+        }
+        changeHappened && this._subscribeCallback?.(this._target);
+    }
+    _lockAnimatedProperties(target, animatedProperties) {
+        let animatedObjectProperties = Animator._getAnimatedObjectProperties(target);
+        for (let key of animatedProperties) {
+            if (animatedObjectProperties.has(key)) {
+                throw new Error(`Animator: target property is already animated! Target: "${JSON.stringify(target, undefined, 2)}", Property: "${key}"`);
+            }
+            animatedObjectProperties.set(key, this);
+        }
+    }
+}
+exports.Animator = Animator;
+//# sourceMappingURL=animator.js.map

package/dist/utilities/animator/animator2/animator.memory-leak.test.d.ts

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

package/dist/utilities/animator/animator2/animator.memory-leak.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+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 animator_1 = require("./animator");
+const ClassNamesToCheck = ['Animator', 'SingleEvent'];
+vitest_1.describe.skipIf(process.env.QUICK)('Memory Leak', () => {
+    (0, vitest_1.beforeEach)(() => {
+        actions_lib_1.ActionLib.hardReset();
+    });
+    async function checkMemoryLeaks(...additionalNames) {
+        await helpers_lib_1.UnitTestHelper.waitForAllOperations();
+        await (0, helpers_lib_1.Wait)();
+        let snapshot = await (0, core_1.takeNodeMinimalHeap)();
+        ClassNamesToCheck.concat(additionalNames).forEach(name => {
+            if (snapshot.hasObjectWithClassName(name)) {
+                throw new Error(`"${name}" has at least one instance in the memory.`);
+            }
+        });
+    }
+    (0, vitest_1.test)('simple animator', async () => {
+        let target = { x: 1 };
+        let animator = new animator_1.Animator(target, 'x');
+        (0, vitest_1.expect)(animator).toBeDefined();
+        animator = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks()).resolves.not.toThrow();
+    }, 60000);
+    (0, vitest_1.test)('sample animation', async () => {
+        let target = { x: 1 };
+        let animator = new animator_1.Animator(target, 'x');
+        let animation = animator.animate({ x: 2 }).attachToRoot();
+        game_entities_1.UpdateCycle.triggerUpdateTick(1);
+        (0, vitest_1.expect)(animation).toBeDefined();
+        animation.destroy();
+        animator = undefined;
+        animation = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks()).resolves.not.toThrow();
+    }, 60000);
+    (0, vitest_1.test)('target contains the animator', async () => {
+        class Foo {
+            constructor() {
+                this.x = 0;
+                this.animator = new animator_1.Animator(this, 'x');
+            }
+        }
+        let foo = new Foo();
+        (0, vitest_1.expect)(foo).toBeDefined();
+        foo = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks(Foo.name)).resolves.not.toThrow();
+    }, 60000);
+    (0, vitest_1.test)('default animation contains the animator', async () => {
+        class FaultyAnimation {
+            start() { }
+            multiplierFunction(t) {
+                return 0;
+            }
+            setAnimator(anim) {
+                this.animator = anim;
+            }
+        }
+        let animation = new FaultyAnimation();
+        let animator = new animator_1.Animator({ x: 1 }, 'x', { animation });
+        animation.setAnimator(animator);
+        (0, vitest_1.expect)(animator).toBeDefined();
+        animation = undefined;
+        animator = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks(FaultyAnimation.name)).resolves.not.toThrow();
+    }, 60000);
+});
+//# sourceMappingURL=animator.memory-leak.test.js.map

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

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

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../game-entities");
+const animator_1 = require("./animator");
+vitest_1.describe.skipIf(!process.env.MANUAL)('Performance Tests', () => {
+    (0, vitest_1.test)('no anim single', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                new animator_1.Animator(obj, 'x', {
+                    duration: 1
+                });
+                resolve();
+            });
+            // old animator: 18.053100109100342
+            // 11.454499959945679
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('no anim multiple', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                new animator_1.Animator(obj, ['x', 'y'], {
+                    duration: 1
+                });
+                resolve();
+            });
+            // old animator: 18.6875
+            // 12.170400142669678
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('single anim with trigger', 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
+                });
+                let animation = animator.animate({ x: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                animation.destroy();
+            });
+            // old animator: 31.59340000152588
+            // 31.48099994659424
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('multiple anim with trigger', 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
+                });
+                let animation = animator.animate({ x: 1, y: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                animation.destroy();
+            });
+            // old animator: 35.71740007400513
+            // 34.62980008125305
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+});
+//# sourceMappingURL=animator.performance.test.js.map

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

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