bard-legends-framework 0.11.0 → 0.12.1

package/dist/utilities/animator/content-animations/slide/state-animation.test.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../../game-entities");
+const state_animation_1 = require("./state-animation");
+var AnimationState;
+(function (AnimationState) {
+    AnimationState[AnimationState["Idle"] = 1] = "Idle";
+    AnimationState[AnimationState["Transitioning"] = 2] = "Transitioning";
+    AnimationState[AnimationState["Reverting"] = 3] = "Reverting";
+})(AnimationState || (AnimationState = {}));
+(0, vitest_1.describe)('StateAnimation', () => {
+    let stateAnimation;
+    let heap = [];
+    (0, vitest_1.beforeEach)(async () => {
+        if (stateAnimation) {
+            stateAnimation.destroy();
+        }
+        heap = [];
+        stateAnimation = new state_animation_1.StateAnimation({ duration: 4 })
+            .onStateChange((state, nextState) => heap.push({ state, nextState }))
+            .onValueChange(value => heap.push(value))
+            .attachToRoot();
+    });
+    (0, vitest_1.describe)('Creation', () => {
+        (0, vitest_1.test)('default values', () => {
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: undefined,
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState('A');
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'A',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('initial value as nullish', () => {
+            stateAnimation.setState('');
+            (0, vitest_1.expect)(heap).toEqual([{ state: '', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: '',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+            heap = [];
+            stateAnimation.setState('B');
+            (0, vitest_1.expect)(heap).toEqual([{ state: '', nextState: 'B' }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: '',
+                nextState: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+    });
+    (0, vitest_1.describe)('Transitioning', () => {
+        (0, vitest_1.beforeEach)(() => {
+            stateAnimation.setState('A');
+            heap = [];
+        });
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState('B');
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: 'B' }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'A',
+                nextState: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('animation in the middle', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: 'B' }, 0, 0.25]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.25,
+                state: 'A',
+                nextState: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('animation end', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: 'B' }, 0, { state: 'B', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'B',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('instant from beggining', async () => {
+            stateAnimation.setState('B', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'B', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'B',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('instant from middle', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            heap = [];
+            stateAnimation.setState('B', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'B', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'B',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+    });
+    (0, vitest_1.describe)('Queued State', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setState('A');
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+        });
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState('C');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'A',
+                nextState: 'B',
+                queuedState: 'C',
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('animation in the middle', async () => {
+            stateAnimation.setState('C');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([0.75]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.75,
+                state: 'A',
+                nextState: 'B',
+                queuedState: 'C',
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('transition start', async () => {
+            stateAnimation.setState('C');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'B', nextState: 'C' }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'B',
+                nextState: 'C',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('transition middle', async () => {
+            stateAnimation.setState('C');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'B', nextState: 'C' }, 0, 0.5]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'B',
+                nextState: 'C',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('transition end', async () => {
+            stateAnimation.setState('C');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'B', nextState: 'C' }, 0, { state: 'C', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'C',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('queued value during reverting', async () => {
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            stateAnimation.setState('C');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([0.75, 0.5, 0.25]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.25,
+                state: 'A',
+                nextState: 'B',
+                queuedState: 'C',
+                animationState: AnimationState.Reverting
+            });
+            heap = [];
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: 'C' }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'A',
+                nextState: 'C',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('instant', async () => {
+            stateAnimation.setState('C', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'C', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'C',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('edge case, setting zero', async () => {
+            let stateAnimationNumber = new state_animation_1.StateAnimation({ duration: 4 }).attachToRoot();
+            stateAnimationNumber.setState(2, { instant: true });
+            stateAnimationNumber.setState(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            stateAnimationNumber.setState(0);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(stateAnimationNumber.currentState).toEqual({
+                value: 0,
+                state: 1,
+                nextState: 0,
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+    });
+    (0, vitest_1.describe)('Reverting', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setState('A');
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(3);
+            heap = [];
+        });
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState('A');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.75,
+                state: 'A',
+                nextState: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Reverting
+            });
+        });
+        (0, vitest_1.test)('animation in the middle', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([0.5]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'A',
+                nextState: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Reverting
+            });
+        });
+        (0, vitest_1.test)('animation end', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(3);
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'A',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('re-reverting', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([0.5, 0.75]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.75,
+                state: 'A',
+                nextState: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+        (0, vitest_1.test)('instant', async () => {
+            stateAnimation.setState('A', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([{ state: 'A', nextState: undefined }, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'A',
+                nextState: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Idle
+            });
+        });
+        (0, vitest_1.test)('edge case, setting zero', async () => {
+            let stateAnimationNumber = new state_animation_1.StateAnimation({ duration: 4 }).attachToRoot();
+            stateAnimationNumber.setState(2, { instant: true });
+            stateAnimationNumber.setState(1);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            stateAnimationNumber.setState(2);
+            stateAnimationNumber.setState(0);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(stateAnimationNumber.currentState).toEqual({
+                value: 0,
+                state: 2,
+                nextState: 0,
+                queuedState: undefined,
+                animationState: AnimationState.Transitioning
+            });
+        });
+    });
+});
+//# sourceMappingURL=state-animation.test.js.map

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

@@ -1,7 +1,7 @@
-export * from './animating-content/fade-in-content';
-export * from './animating-content/slide-in-content';
 export * from './animations';
-export * from './animator';
-export * from './state-animation/slide-state-animation';
-export * from './state-animation/state-animation';
-export * from './state-animation/visit-disappear-state-animation';
+export * from './animator/animator';
+export * from './content-animations/fade-in/fade-in-content';
+export * from './content-animations/fade-in/fade-in-state-animation';
+export * from './content-animations/slide/slide-in-content';
+export * from './content-animations/slide/slide-state-animation';
+export * from './content-animations/slide/state-animation';

package/dist/utilities/animator/index.js

@@ -14,11 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./animating-content/fade-in-content"), exports);
-__exportStar(require("./animating-content/slide-in-content"), exports);
 __exportStar(require("./animations"), exports);
-__exportStar(require("./animator"), exports);
-__exportStar(require("./state-animation/slide-state-animation"), exports);
-__exportStar(require("./state-animation/state-animation"), exports);
-__exportStar(require("./state-animation/visit-disappear-state-animation"), exports);
+__exportStar(require("./animator/animator"), exports);
+__exportStar(require("./content-animations/fade-in/fade-in-content"), exports);
+__exportStar(require("./content-animations/fade-in/fade-in-state-animation"), exports);
+__exportStar(require("./content-animations/slide/slide-in-content"), exports);
+__exportStar(require("./content-animations/slide/slide-state-animation"), exports);
+__exportStar(require("./content-animations/slide/state-animation"), exports);
 //# sourceMappingURL=index.js.map

package/dist/utilities/animator/state-animation/fade-in/fade-in-content.d.ts

@@ -0,0 +1,18 @@
+import { Container } from '../../../../pixi';
+import { AnimatorAnimation } from '../../animations';
+export interface FadeInContentOptions {
+    duration: number;
+    animation: AnimatorAnimation;
+}
+export declare class FadeInContent<T> extends Container {
+    private createFunction;
+    private stateAnimation;
+    private content;
+    constructor(createFunction: (value: {
+        state: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<FadeInContentOptions>);
+    setState(state: T | undefined, options?: {
+        instant?: boolean;
+    }): this;
+}

package/dist/utilities/animator/state-animation/fade-in/fade-in-content.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FadeInContent = void 0;
+const pixi_1 = require("../../../../pixi");
+const animations_1 = require("../../animations");
+const fade_in_state_animation_1 = require("./fade-in-state-animation");
+class FadeInContent extends pixi_1.Container {
+    constructor(createFunction, partialOptions) {
+        super();
+        this.createFunction = createFunction;
+        let options = {
+            duration: 200,
+            animation: animations_1.Animations.easeInOut,
+            ...partialOptions
+        };
+        this.alpha = 0;
+        this.stateAnimation = new fade_in_state_animation_1.FadeInStateAnimation(options)
+            .onStateChange(state => {
+            this.content?.destroy();
+            this.content = undefined;
+            if (state !== undefined) {
+                this.content = new pixi_1.Container().displayParent(this).attach(this);
+                this.createFunction({ state, container: this.content });
+            }
+        })
+            .onValueChange(value => {
+            this.alpha = value;
+        })
+            .attach(this);
+    }
+    setState(state, options) {
+        this.stateAnimation.setState(state, options);
+        return this;
+    }
+}
+exports.FadeInContent = FadeInContent;
+//# sourceMappingURL=fade-in-content.js.map

package/dist/utilities/animator/state-animation/fade-in/fade-in-content.test.d.ts

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

package/dist/utilities/animator/state-animation/fade-in/fade-in-content.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fade_in_content_1 = require("./fade-in-content");
+(0, vitest_1.describe)('Fade In Content', () => {
+    (0, vitest_1.test)('should exist', () => {
+        (0, vitest_1.expect)(fade_in_content_1.FadeInContent).toBeDefined();
+    });
+});
+//# sourceMappingURL=fade-in-content.test.js.map

package/dist/utilities/animator/state-animation/fade-in/fade-in-state-animation.d.ts

@@ -0,0 +1,32 @@
+import { Attachable } from 'actions-lib';
+import { StateAnimationOptions } from '../state-animation';
+type AnimationState = 'hidden' | 'visible' | 'appearing' | 'disappearing' | 'disappearToChange';
+export declare class FadeInStateAnimation<T> extends Attachable {
+    private animator;
+    private options;
+    private value;
+    private state;
+    private queuedState;
+    private animationState;
+    get currentState(): {
+        value: number;
+        state: T | undefined;
+        queuedState: T | undefined;
+        animationState: AnimationState;
+    };
+    constructor(partialOptions?: Partial<StateAnimationOptions>);
+    /**
+     * @param state - The new state to set. Keep in mind falsy values are also considered as a new state. To set the state to "disappear" use undefined.
+     * @param options - Optional options.
+     * @param options.instant - If true, the state will be set immediately.
+     */
+    setState(state: T | undefined, options?: {
+        instant?: boolean;
+    }): void;
+    private onComplete;
+    private onStateChangeAction;
+    private onValueChangeAction;
+    onStateChange(callback: (state: T | undefined) => void): this;
+    onValueChange(callback: (value: number) => void): this;
+}
+export {};

package/dist/utilities/animator/state-animation/fade-in/fade-in-state-animation.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FadeInStateAnimation = void 0;
+const actions_lib_1 = require("actions-lib");
+const animations_1 = require("../../animations");
+const animator_1 = require("../../animator/animator");
+class FadeInStateAnimation extends actions_lib_1.Attachable {
+    get currentState() {
+        return {
+            value: this.value,
+            state: this.state,
+            queuedState: this.queuedState,
+            animationState: this.animationState
+        };
+    }
+    constructor(partialOptions) {
+        super();
+        this.animationState = 'hidden';
+        this.onStateChangeAction = new actions_lib_1.Action();
+        this.onValueChangeAction = new actions_lib_1.Action();
+        this.options = { duration: 500, animation: animations_1.Animations.lineer, ...partialOptions };
+        this.value = 0;
+        this.animator = new animator_1.Animator(this, 'value', {
+            duration: this.options.duration,
+            animation: this.options.animation,
+            reAnimateHandling: animator_1.ReAnimateHandlingType.completePrevious,
+            completeAnimationsHandling: animator_1.CompleteAnimationsHandlingType.stayInCurrentState
+        })
+            .onComplete((key, value) => this.onComplete(value))
+            .onChange(() => this.onValueChangeAction.trigger(this.value))
+            .attach(this);
+    }
+    /**
+     * @param state - The new state to set. Keep in mind falsy values are also considered as a new state. To set the state to "disappear" use undefined.
+     * @param options - Optional options.
+     * @param options.instant - If true, the state will be set immediately.
+     */
+    setState(state, options) {
+        if (options?.instant) {
+            this.animator.completeAnimations();
+            this.animationState = state !== undefined ? 'visible' : 'hidden';
+            this.queuedState = undefined;
+            let value = state !== undefined ? 1 : 0;
+            let differentState = this.state !== state;
+            if (differentState) {
+                this.state = state;
+                this.onStateChangeAction.trigger(this.state);
+            }
+            if (differentState || this.value !== value) {
+                this.value = value;
+                this.onValueChangeAction.trigger(this.value);
+            }
+        }
+        else {
+            switch (this.animationState) {
+                case 'hidden':
+                    if (state !== undefined) {
+                        this.animationState = 'appearing';
+                        this.queuedState = undefined;
+                        this.state = state;
+                        this.onStateChangeAction.trigger(this.state);
+                        this.animator.animate({ value: 1 }).attachToRoot(); // TODO
+                    }
+                    break;
+                case 'visible':
+                    if (state === undefined) {
+                        this.animationState = 'disappearing';
+                        this.queuedState = undefined;
+                        this.animator.animate({ value: 0 }).attachToRoot(); // TODO
+                    }
+                    else if (state !== this.state) {
+                        this.animationState = 'disappearToChange';
+                        this.queuedState = state;
+                        this.animator.animate({ value: 0 }).attachToRoot(); // TODO
+                    }
+                    break;
+                case 'appearing':
+                    if (state === undefined) {
+                        this.animationState = 'disappearing';
+                        this.queuedState = undefined;
+                        this.animator.animate({ value: 0 }, { duration: this.value * this.options.duration }).attachToRoot(); // TODO
+                    }
+                    else if (state !== this.state) {
+                        if (this.value > 0) {
+                            this.animationState = 'disappearToChange';
+                            this.queuedState = state;
+                            this.animator.animate({ value: 0 }, { duration: this.value * this.options.duration }).attachToRoot(); // TODO
+                        }
+                        else {
+                            this.queuedState = undefined;
+                            this.state = state;
+                            this.onStateChangeAction.trigger(this.state);
+                        }
+                    }
+                    break;
+                case 'disappearing':
+                    if (state === this.state) {
+                        this.animationState = 'appearing';
+                        this.animator.animate({ value: 1 }, { duration: (1 - this.value) * this.options.duration }).attachToRoot(); // TODO
+                    }
+                    else if (state !== undefined) {
+                        this.animationState = 'disappearToChange';
+                        this.queuedState = state;
+                    }
+                    break;
+                case 'disappearToChange':
+                    if (state === undefined) {
+                        this.animationState = 'disappearing';
+                        this.queuedState = undefined;
+                    }
+                    else if (state === this.state) {
+                        this.animationState = 'appearing';
+                        this.queuedState = undefined;
+                        this.animator.animate({ value: 1 }, { duration: (1 - this.value) * this.options.duration }).attachToRoot(); // TODO
+                    }
+                    else if (state !== this.queuedState) {
+                        this.queuedState = state;
+                    }
+                    break;
+            }
+        }
+    }
+    onComplete(value) {
+        switch (this.animationState) {
+            case 'appearing':
+                if (value === 1) {
+                    this.animationState = 'visible';
+                }
+                break;
+            case 'disappearing':
+                if (this.queuedState !== undefined) {
+                    throw new Error('FadeInStateAnimation: Unexpected state, disappearing should not have a queued value');
+                }
+                if (value === 0) {
+                    this.animationState = 'hidden';
+                    this.state = undefined;
+                    this.onStateChangeAction.trigger(this.state);
+                }
+                break;
+            case 'disappearToChange':
+                if (this.queuedState === undefined) {
+                    throw new Error('FadeInStateAnimation: Unexpected state, disappearToChange should always have a queued value');
+                }
+                if (value === 0) {
+                    this.animationState = 'appearing';
+                    this.state = this.queuedState;
+                    this.queuedState = undefined;
+                    this.onStateChangeAction.trigger(this.state);
+                    this.animator.animate({ value: 1 }).attachToRoot(); // TODO
+                }
+                break;
+            case 'hidden':
+            case 'visible':
+                // Do nothing
+                break;
+        }
+    }
+    onStateChange(callback) {
+        this.onStateChangeAction.subscribe(value => callback(value)).attach(this);
+        return this;
+    }
+    onValueChange(callback) {
+        this.onValueChangeAction.subscribe(value => callback(value)).attach(this);
+        return this;
+    }
+}
+exports.FadeInStateAnimation = FadeInStateAnimation;
+//# sourceMappingURL=fade-in-state-animation.js.map

package/dist/utilities/animator/state-animation/fade-in/fade-in-state-animation.test.d.ts

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