bard-legends-framework 0.10.9 → 0.11.0

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

@@ -0,0 +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';

package/dist/utilities/animator/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+//# sourceMappingURL=index.js.map

package/dist/utilities/animator/state-animation/slide-state-animation.d.ts

@@ -0,0 +1,24 @@
+import { Attachable } from 'actions-lib';
+import { StateAnimationOptions } from './state-animation';
+export declare enum SlideStateAnimationState {
+    appear = "appear",
+    disappear = "disappear"
+}
+export declare class SlideStateAnimation extends Attachable {
+    private stateAnimation;
+    private options;
+    private index;
+    private nextIndex;
+    private animationState;
+    constructor(partialOptions?: Partial<StateAnimationOptions>);
+    setIndex(index: number, options?: {
+        instant?: boolean;
+    }): void;
+    private handleStateChange;
+    private handleValueChange;
+    private handleNewTarget;
+    private onStateChangeAction;
+    private onValueChangeAction;
+    onStateChange(callback: (state: SlideStateAnimationState, index: number) => void): this;
+    onValueChange(callback: (value: number, index: number) => void): this;
+}

package/dist/utilities/animator/state-animation/slide-state-animation.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlideStateAnimation = exports.SlideStateAnimationState = void 0;
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const animations_1 = require("../animations");
+const state_animation_1 = require("./state-animation");
+var SlideStateAnimationState;
+(function (SlideStateAnimationState) {
+    SlideStateAnimationState["appear"] = "appear";
+    SlideStateAnimationState["disappear"] = "disappear";
+})(SlideStateAnimationState || (exports.SlideStateAnimationState = SlideStateAnimationState = {}));
+class SlideStateAnimation extends actions_lib_1.Attachable {
+    constructor(partialOptions) {
+        super();
+        this.animationState = 'idle';
+        this.onStateChangeAction = new actions_lib_1.Action();
+        this.onValueChangeAction = new actions_lib_1.Action();
+        this.options = { duration: 500, animation: new animations_1.AnimationEaseInOutCubic(), ...partialOptions };
+        this.stateAnimation = new state_animation_1.StateAnimation({
+            duration: this.options.duration,
+            animation: this.options.animation
+        })
+            .onStateChange((state, nextState) => this.handleStateChange(state, nextState))
+            .onValueChange(value => this.handleValueChange(value))
+            .attach(this);
+    }
+    setIndex(index, options) {
+        if (!helpers_lib_1.Comparator.isInteger(index)) {
+            throw new Error('SlideStateAnimation: index must be an integer!');
+        }
+        if (this.index === undefined) {
+            this.index = index;
+            this.onStateChangeAction.trigger({ state: SlideStateAnimationState.appear, index });
+            this.stateAnimation.setState(index, options);
+        }
+        else if (this.index !== index) {
+            if (this.nextIndex !== index) {
+                if (this.animationState === 'idle') {
+                    this.animationState = index > this.index ? 'transitionForward' : 'transitionBackward';
+                    this.nextIndex = index;
+                    this.onStateChangeAction.trigger({ state: SlideStateAnimationState.appear, index: this.nextIndex });
+                    this.stateAnimation.setState(index, options);
+                }
+                else {
+                    this.stateAnimation.setState(index, options);
+                }
+            }
+            else if (this.animationState === 'reverting' && this.nextIndex === index) {
+                this.animationState = index > this.index ? 'transitionForward' : 'transitionBackward';
+                this.stateAnimation.setState(index, options);
+            }
+        }
+        else if (this.animationState === 'transitionForward' || this.animationState === 'transitionBackward') {
+            this.animationState = 'reverting';
+            this.stateAnimation.setState(index, options);
+        }
+    }
+    handleStateChange(state, nextState) {
+        if (this.index !== undefined && this.index !== state && this.index !== nextState) {
+            this.onStateChangeAction.trigger({ state: SlideStateAnimationState.disappear, index: this.index });
+        }
+        if (this.nextIndex !== undefined && this.nextIndex !== state && this.nextIndex !== nextState) {
+            this.onStateChangeAction.trigger({ state: SlideStateAnimationState.disappear, index: this.nextIndex });
+        }
+        if (nextState !== undefined && nextState !== this.index && nextState !== this.nextIndex) {
+            this.onStateChangeAction.trigger({ state: SlideStateAnimationState.appear, index: nextState });
+        }
+        switch (this.animationState) {
+            case 'transitionForward':
+            case 'transitionBackward':
+                if (nextState === undefined) {
+                    this.animationState = 'idle';
+                    this.index = this.nextIndex;
+                    this.nextIndex = undefined;
+                }
+                else if (this.index !== state) {
+                    this.handleNewTarget(state, nextState);
+                }
+                break;
+            case 'reverting':
+                if (nextState === undefined) {
+                    this.animationState = 'idle';
+                    this.nextIndex = undefined;
+                }
+                else if (this.index !== nextState) {
+                    this.handleNewTarget(state, nextState);
+                }
+                break;
+        }
+    }
+    handleValueChange(value) {
+        let directionMultiplier = 1;
+        if (this.animationState === 'transitionBackward' ||
+            (this.animationState === 'reverting' &&
+                this.index !== undefined &&
+                this.nextIndex !== undefined &&
+                this.index > this.nextIndex)) {
+            directionMultiplier = -1;
+        }
+        if (this.animationState === 'idle' || value !== 0) {
+            this.onValueChangeAction.trigger({
+                value: helpers_lib_1.NumberHelper.ensurePositiveZero(-directionMultiplier * value),
+                index: this.index
+            });
+        }
+        if (this.nextIndex !== undefined) {
+            this.onValueChangeAction.trigger({
+                value: helpers_lib_1.NumberHelper.ensurePositiveZero(directionMultiplier * (1 - value)),
+                index: this.nextIndex
+            });
+        }
+    }
+    handleNewTarget(state, nextState) {
+        this.index = state;
+        this.nextIndex = nextState;
+        this.onValueChangeAction.trigger({ value: 0, index: this.index });
+        this.animationState = this.index < this.nextIndex ? 'transitionForward' : 'transitionBackward';
+    }
+    onStateChange(callback) {
+        this.onStateChangeAction.subscribe(value => callback(value.state, value.index)).attach(this);
+        return this;
+    }
+    onValueChange(callback) {
+        this.onValueChangeAction.subscribe(value => callback(value.value, value.index)).attach(this);
+        return this;
+    }
+}
+exports.SlideStateAnimation = SlideStateAnimation;
+//# sourceMappingURL=slide-state-animation.js.map

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

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

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

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../game-entities");
+const animations_1 = require("../animations");
+const slide_state_animation_1 = require("./slide-state-animation");
+(0, vitest_1.describe)('SlideStateAnimation', () => {
+    let stateAnimation;
+    let heap = [];
+    (0, vitest_1.beforeEach)(async () => {
+        if (stateAnimation) {
+            stateAnimation.destroy();
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+        }
+        heap = [];
+        stateAnimation = new slide_state_animation_1.SlideStateAnimation({ duration: 4, animation: new animations_1.AnimationLineer() })
+            .onStateChange((state, index) => heap.push({ state, index }))
+            .onValueChange((value, index) => heap.push({ value, index }))
+            .attachToRoot();
+    });
+    (0, vitest_1.describe)('Creation', () => {
+        (0, vitest_1.test)('initial values', () => {
+            (0, vitest_1.expect)(stateAnimation).toBeDefined();
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+        });
+        (0, vitest_1.test)('initial state default', () => {
+            stateAnimation.setIndex(0);
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 0 },
+                { value: 0, index: 0 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+        });
+        (0, vitest_1.test)('initial state instant', () => {
+            stateAnimation.setIndex(0, { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 0 },
+                { value: 0, index: 0 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+        });
+        (0, vitest_1.test)('setting same index', () => {
+            stateAnimation.setIndex(0);
+            heap = [];
+            stateAnimation.setIndex(0);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+        });
+    });
+    (0, vitest_1.describe)('Slide Next', () => {
+        (0, vitest_1.beforeEach)(() => {
+            stateAnimation.setIndex(0);
+            heap = [];
+            stateAnimation.setIndex(1);
+        });
+        (0, vitest_1.test)('initial state', () => {
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 1 },
+                { value: 1, index: 1 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+        });
+        (0, vitest_1.test)('during the animation', async () => {
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: -0.25, index: 0 },
+                { value: 0.75, index: 1 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+        });
+        (0, vitest_1.test)('end of the animation', async () => {
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(3);
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 0 },
+                { value: 0, index: 1 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+        });
+        (0, vitest_1.test)('animating again', async () => {
+            await game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            heap = [];
+            stateAnimation.setIndex(2);
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 2 },
+                { value: 1, index: 2 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+        });
+        (0, vitest_1.test)('setting same index', async () => {
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            heap = [];
+            stateAnimation.setIndex(1);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+        });
+    });
+    (0, vitest_1.describe)('Slide Previous', () => {
+        (0, vitest_1.beforeEach)(() => {
+            stateAnimation.setIndex(1);
+            heap = [];
+            stateAnimation.setIndex(0);
+        });
+        (0, vitest_1.test)('initial state', () => {
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 0 },
+                { value: -1, index: 0 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+        });
+        (0, vitest_1.test)('during the animation', async () => {
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 0 },
+                { value: -1, index: 0 },
+                { value: 0.25, index: 1 },
+                { value: -0.75, index: 0 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+        });
+        (0, vitest_1.test)('end of the animation', async () => {
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(3);
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 1 },
+                { value: 0, index: 0 }
+            ]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+        });
+    });
+    (0, vitest_1.describe)('Reverting', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setIndex(0);
+        });
+        (0, vitest_1.test)('forward reverting', async () => {
+            stateAnimation.setIndex(1);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setIndex(0);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: -0.25, index: 0 },
+                { value: 0.75, index: 1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 1 },
+                { value: 0, index: 0 }
+            ]);
+        });
+        (0, vitest_1.test)('backward reverting', async () => {
+            stateAnimation.setIndex(-1);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setIndex(0);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: 0.25, index: 0 },
+                { value: -0.75, index: -1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: -1 },
+                { value: 0, index: 0 }
+            ]);
+        });
+        (0, vitest_1.test)('re-reverting', async () => {
+            stateAnimation.setIndex(1);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setIndex(0);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: -0.25, index: 0 },
+                { value: 0.75, index: 1 }
+            ]);
+            heap = [];
+            stateAnimation.setIndex(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: -0.75, index: 0 },
+                { value: 0.25, index: 1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 0 },
+                { value: 0, index: 1 }
+            ]);
+        });
+        (0, vitest_1.test)('setting same index', async () => {
+            stateAnimation.setIndex(1);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setIndex(0);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            heap = [];
+            stateAnimation.setIndex(0);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+        });
+    });
+    (0, vitest_1.describe)('Re-targeting', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setIndex(0);
+            stateAnimation.setIndex(2);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+        });
+        (0, vitest_1.test)('changing target in transitioning', async () => {
+            stateAnimation.setIndex(1);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: -0.75, index: 0 },
+                { value: 0.25, index: 2 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 0 },
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 1 },
+                { value: 0, index: 2 },
+                { value: -1, index: 1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: 0.25, index: 2 },
+                { value: -0.75, index: 1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(3);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 2 },
+                { value: 0, index: 1 }
+            ]);
+        });
+        (0, vitest_1.test)('changing target in reverting', async () => {
+            stateAnimation.setIndex(0);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            heap = [];
+            stateAnimation.setIndex(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('reverting');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 2 },
+                { state: slide_state_animation_1.SlideStateAnimationState.appear, index: 1 },
+                { value: 0, index: 0 },
+                { value: 1, index: 1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('transitioning');
+            (0, vitest_1.expect)(heap).toEqual([
+                { value: -0.25, index: 0 },
+                { value: 0.75, index: 1 }
+            ]);
+            heap = [];
+            await game_entities_1.UpdateCycle.triggerUpdateTick(3);
+            (0, vitest_1.expect)(stateAnimation['stateAnimation']['animationState']).toBe('idle');
+            (0, vitest_1.expect)(heap).toEqual([
+                { state: slide_state_animation_1.SlideStateAnimationState.disappear, index: 0 },
+                { value: 0, index: 1 }
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('Error Cases:', () => {
+        (0, vitest_1.test)('index must be an integer', async () => {
+            (0, vitest_1.expect)(() => stateAnimation.setIndex(0.25)).toThrowError('SlideStateAnimation: index must be an integer!');
+        });
+    });
+});
+//# sourceMappingURL=slide-state-animation.test.js.map

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

@@ -0,0 +1,33 @@
+import { Attachable } from 'actions-lib';
+import { AnimatorAnimation } from '../animations';
+export interface StateAnimationOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+}
+type AnimationState = 'idle' | 'transitioning' | 'reverting';
+export declare class StateAnimation<T> extends Attachable {
+    private animator;
+    private options;
+    private value;
+    private state;
+    private nextState;
+    private queuedState;
+    private animationState;
+    get currentState(): {
+        value: number;
+        state: T | undefined;
+        nextState: T | undefined;
+        queuedState: T | undefined;
+        animationState: AnimationState;
+    };
+    constructor(partialOptions?: Partial<StateAnimationOptions>);
+    setState(state: T, options?: {
+        instant?: boolean;
+    }): void;
+    private onComplete;
+    private onStateChangeAction;
+    private onValueChangeAction;
+    onStateChange(callback: (state: T, nextState?: T) => void): this;
+    onValueChange(callback: (value: number) => void): this;
+}
+export {};

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAnimation = void 0;
+const actions_lib_1 = require("actions-lib");
+const animations_1 = require("../animations");
+const animator_1 = require("../animator");
+class StateAnimation extends actions_lib_1.Attachable {
+    get currentState() {
+        return {
+            value: this.value,
+            state: this.state,
+            nextState: this.nextState,
+            queuedState: this.queuedState,
+            animationState: this.animationState
+        };
+    }
+    constructor(partialOptions) {
+        super();
+        this.animationState = 'idle';
+        this.onStateChangeAction = new actions_lib_1.Action();
+        this.onValueChangeAction = new actions_lib_1.Action();
+        this.options = { duration: 500, animation: new animations_1.AnimationLineer(), ...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.value = this.value === 1 ? 0 : this.value;
+            this.onValueChangeAction.trigger(this.value);
+        })
+            .attach(this);
+    }
+    setState(state, options) {
+        if (this.state === undefined) {
+            this.state = state;
+            this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+            this.onValueChangeAction.trigger(this.value);
+        }
+        else if (options?.instant) {
+            this.animator.completeAnimations();
+            this.animationState = 'idle';
+            this.state = state;
+            this.nextState = undefined;
+            this.value = 0;
+            this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+            this.onValueChangeAction.trigger(this.value);
+        }
+        else {
+            switch (this.animationState) {
+                case 'idle':
+                    if (state !== this.state) {
+                        this.animationState = 'transitioning';
+                        this.nextState = state;
+                        this.value = 0;
+                        this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+                        this.onValueChangeAction.trigger(this.value);
+                        this.animator.animate({ value: 1 });
+                    }
+                    break;
+                case 'transitioning':
+                    if (state !== this.nextState) {
+                        if (state === this.state) {
+                            this.animationState = 'reverting';
+                            this.animator.animate({ value: 0 }, { duration: this.value * this.options.duration });
+                        }
+                        else {
+                            this.queuedState = state;
+                        }
+                    }
+                    break;
+                case 'reverting':
+                    if (state !== this.state) {
+                        if (state === this.nextState) {
+                            this.animationState = 'transitioning';
+                            this.animator.animate({ value: 1 }, { duration: (1 - this.value) * this.options.duration });
+                        }
+                        else {
+                            this.queuedState = state;
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+    onComplete(value) {
+        switch (this.animationState) {
+            case 'transitioning':
+                if (value === 1) {
+                    if (this.queuedState !== undefined) {
+                        this.animationState = 'transitioning';
+                        this.state = this.nextState;
+                        this.nextState = this.queuedState;
+                        this.queuedState = undefined;
+                        this.value = 0;
+                        this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+                        this.animator.animate({ value: 1 });
+                    }
+                    else {
+                        this.animationState = 'idle';
+                        this.state = this.nextState;
+                        this.nextState = undefined;
+                        this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+                    }
+                }
+                break;
+            case 'reverting':
+                if (this.state === undefined) {
+                    throw new Error('StateAnimation: state must be defined when reverting!');
+                }
+                if (value === 0) {
+                    if (this.queuedState !== undefined) {
+                        this.animationState = 'transitioning';
+                        this.nextState = this.queuedState;
+                        this.queuedState = undefined;
+                        this.value = 0;
+                        this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+                        this.animator.animate({ value: 1 });
+                    }
+                    else {
+                        this.animationState = 'idle';
+                        this.nextState = undefined;
+                        this.value = 0;
+                        this.onStateChangeAction.trigger({ state: this.state, nextState: this.nextState });
+                    }
+                }
+                break;
+            case 'idle':
+                // Do nothing
+                break;
+        }
+    }
+    onStateChange(callback) {
+        this.onStateChangeAction.subscribe(value => callback(value.state, value.nextState)).attach(this);
+        return this;
+    }
+    onValueChange(callback) {
+        this.onValueChangeAction.subscribe(value => callback(value)).attach(this);
+        return this;
+    }
+}
+exports.StateAnimation = StateAnimation;
+//# sourceMappingURL=state-animation.js.map

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

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