bard-legends-framework 0.12.1 → 1.0.0-rc0

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

@@ -1,42 +0,0 @@
-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

@@ -1,222 +0,0 @@
-"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

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

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

@@ -1,73 +0,0 @@
-"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

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

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

@@ -1,65 +0,0 @@
-"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

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