bard-legends-framework 0.12.0 → 1.0.0-rc0

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

@@ -1,138 +0,0 @@
-"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[SlideStateAnimationState["Appear"] = 1] = "Appear";
-    SlideStateAnimationState[SlideStateAnimationState["Disappear"] = 2] = "Disappear";
-})(SlideStateAnimationState || (exports.SlideStateAnimationState = SlideStateAnimationState = {}));
-var AnimationState;
-(function (AnimationState) {
-    AnimationState[AnimationState["Idle"] = 1] = "Idle";
-    AnimationState[AnimationState["TransitionForward"] = 2] = "TransitionForward";
-    AnimationState[AnimationState["TransitionBackward"] = 3] = "TransitionBackward";
-    AnimationState[AnimationState["Reverting"] = 4] = "Reverting";
-})(AnimationState || (AnimationState = {}));
-class SlideStateAnimation extends actions_lib_1.Attachable {
-    constructor(partialOptions) {
-        super();
-        this._animationState = AnimationState.Idle;
-        this._onStateChangeAction = new actions_lib_1.Action();
-        this._onValueChangeAction = new actions_lib_1.Action();
-        this._options = { duration: 500, animation: animations_1.Animations.easeInOutCubic, ...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 === AnimationState.Idle) {
-                    this._animationState = index > this._index ? AnimationState.TransitionForward : AnimationState.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 === AnimationState.Reverting && this._nextIndex === index) {
-                this._animationState = index > this._index ? AnimationState.TransitionForward : AnimationState.TransitionBackward;
-                this._stateAnimation.setState(index, options);
-            }
-        }
-        else if (this._animationState === AnimationState.TransitionForward ||
-            this._animationState === AnimationState.TransitionBackward) {
-            this._animationState = 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 AnimationState.TransitionForward:
-            case AnimationState.TransitionBackward:
-                if (nextState === undefined) {
-                    this._animationState = AnimationState.Idle;
-                    this._index = this._nextIndex;
-                    this._nextIndex = undefined;
-                }
-                else if (this._index !== state) {
-                    this._handleNewTarget(state, nextState);
-                }
-                break;
-            case AnimationState.Reverting:
-                if (nextState === undefined) {
-                    this._animationState = AnimationState.Idle;
-                    this._nextIndex = undefined;
-                }
-                else if (this._index !== nextState) {
-                    this._handleNewTarget(state, nextState);
-                }
-                break;
-        }
-    }
-    _handleValueChange(value) {
-        let directionMultiplier = 1;
-        if (this._animationState === AnimationState.TransitionBackward ||
-            (this._animationState === AnimationState.Reverting &&
-                this._index !== undefined &&
-                this._nextIndex !== undefined &&
-                this._index > this._nextIndex)) {
-            directionMultiplier = -1;
-        }
-        if (this._animationState === 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 ? AnimationState.TransitionForward : AnimationState.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/content-animations/slide/slide-state-animation.test.d.ts

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

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

@@ -1,307 +0,0 @@
-"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");
-var AnimationState;
-(function (AnimationState) {
-    AnimationState[AnimationState["Idle"] = 1] = "Idle";
-    AnimationState[AnimationState["Transitioning"] = 2] = "Transitioning";
-    AnimationState[AnimationState["Rreverting"] = 3] = "Rreverting";
-})(AnimationState || (AnimationState = {}));
-(0, vitest_1.describe)('SlideStateAnimation', () => {
-    let stateAnimation;
-    let heap = [];
-    (0, vitest_1.beforeEach)(async () => {
-        if (stateAnimation) {
-            stateAnimation.destroy();
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-        }
-        heap = [];
-        stateAnimation = new slide_state_animation_1.SlideStateAnimation({ duration: 4, animation: animations_1.Animations.lineer })
-            .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(AnimationState.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(AnimationState.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(AnimationState.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(AnimationState.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(AnimationState.Transitioning);
-        });
-        (0, vitest_1.test)('during the animation', async () => {
-            heap = [];
-            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(AnimationState.Transitioning);
-        });
-        (0, vitest_1.test)('end of the animation', async () => {
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            heap = [];
-            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(AnimationState.Idle);
-        });
-        (0, vitest_1.test)('animating again', async () => {
-            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(AnimationState.Transitioning);
-        });
-        (0, vitest_1.test)('setting same index', async () => {
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            heap = [];
-            stateAnimation.setIndex(1);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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(AnimationState.Transitioning);
-        });
-        (0, vitest_1.test)('during the animation', async () => {
-            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(AnimationState.Transitioning);
-        });
-        (0, vitest_1.test)('end of the animation', async () => {
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            heap = [];
-            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(AnimationState.Idle);
-        });
-    });
-    (0, vitest_1.describe)('Reverting', () => {
-        (0, vitest_1.beforeEach)(async () => {
-            stateAnimation.setIndex(0);
-        });
-        (0, vitest_1.test)('forward reverting', async () => {
-            stateAnimation.setIndex(1);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setIndex(0);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-            (0, vitest_1.expect)(heap).toEqual([
-                { value: -0.25, index: 0 },
-                { value: 0.75, index: 1 }
-            ]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setIndex(0);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-            (0, vitest_1.expect)(heap).toEqual([
-                { value: 0.25, index: 0 },
-                { value: -0.75, index: -1 }
-            ]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setIndex(0);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-            (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(AnimationState.Transitioning);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Transitioning);
-            (0, vitest_1.expect)(heap).toEqual([
-                { value: -0.75, index: 0 },
-                { value: 0.25, index: 1 }
-            ]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setIndex(0);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            heap = [];
-            stateAnimation.setIndex(0);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-        });
-    });
-    (0, vitest_1.describe)('Re-targeting', () => {
-        (0, vitest_1.beforeEach)(async () => {
-            stateAnimation.setIndex(0);
-            stateAnimation.setIndex(2);
-            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(AnimationState.Transitioning);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Transitioning);
-            (0, vitest_1.expect)(heap).toEqual([
-                { value: -0.75, index: 0 },
-                { value: 0.25, index: 2 }
-            ]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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 = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Transitioning);
-            (0, vitest_1.expect)(heap).toEqual([
-                { value: 0.25, index: 2 },
-                { value: -0.75, index: 1 }
-            ]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(3);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            heap = [];
-            stateAnimation.setIndex(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Rreverting);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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 = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.Transitioning);
-            (0, vitest_1.expect)(heap).toEqual([
-                { value: -0.25, index: 0 },
-                { value: 0.75, index: 1 }
-            ]);
-            heap = [];
-            game_entities_1.UpdateCycle.triggerUpdateTick(3);
-            (0, vitest_1.expect)(stateAnimation['_stateAnimation']['_animationState']).toBe(AnimationState.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/content-animations/slide/state-animation.d.ts

@@ -1,37 +0,0 @@
-import { Attachable } from 'actions-lib';
-import { AnimatorAnimation } from '../../animations';
-export interface StateAnimationOptions {
-    readonly duration: number;
-    readonly animation: AnimatorAnimation;
-}
-declare enum AnimationState {
-    Idle = 1,
-    Transitioning = 2,
-    Reverting = 3
-}
-export declare class StateAnimation<T> extends Attachable {
-    private _animator;
-    private _options;
-    private _animatedObject;
-    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/content-animations/slide/state-animation.js

@@ -1,170 +0,0 @@
-"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/animator");
-var AnimationState;
-(function (AnimationState) {
-    AnimationState[AnimationState["Idle"] = 1] = "Idle";
-    AnimationState[AnimationState["Transitioning"] = 2] = "Transitioning";
-    AnimationState[AnimationState["Reverting"] = 3] = "Reverting";
-})(AnimationState || (AnimationState = {}));
-class StateAnimation extends actions_lib_1.Attachable {
-    get currentState() {
-        return {
-            value: this._animatedObject.value,
-            state: this._state,
-            nextState: this._nextState,
-            queuedState: this._queuedState,
-            animationState: this._animationState
-        };
-    }
-    constructor(partialOptions) {
-        super();
-        this._animatedObject = { value: 0 };
-        this._animationState = AnimationState.Idle;
-        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._animator = new animator_1.Animator(this._animatedObject, 'value', {
-            duration: this._options.duration,
-            animation: this._options.animation,
-            reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
-            completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
-        });
-        this._animator.value
-            .subscribe(() => {
-            if (this._animatedObject.value !== 1 && this._animatedObject.value !== 0) {
-                this._onValueChangeAction.trigger(this._animatedObject.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._animatedObject.value);
-        }
-        else if (options?.instant) {
-            this._animator.completeAnimation();
-            this._animationState = AnimationState.Idle;
-            this._state = state;
-            this._nextState = undefined;
-            this._animatedObject.value = 0;
-            this._onStateChangeAction.trigger({ state: this._state, nextState: this._nextState });
-            this._onValueChangeAction.trigger(this._animatedObject.value);
-        }
-        else {
-            switch (this._animationState) {
-                case AnimationState.Idle:
-                    if (state !== this._state) {
-                        this._animationState = AnimationState.Transitioning;
-                        this._nextState = state;
-                        this._animatedObject.value = 0;
-                        this._onStateChangeAction.trigger({ state: this._state, nextState: this._nextState });
-                        this._onValueChangeAction.trigger(this._animatedObject.value);
-                        this._animator
-                            .animate({ value: 1 })
-                            .tap(() => this._onComplete())
-                            .attach(this);
-                    }
-                    break;
-                case AnimationState.Transitioning:
-                    if (state !== this._nextState) {
-                        if (state === this._state) {
-                            this._animationState = AnimationState.Reverting;
-                            this._animator
-                                .animate({ value: 0 }, { duration: this._animatedObject.value * this._options.duration })
-                                .tap(() => this._onComplete())
-                                .attach(this);
-                        }
-                        else {
-                            this._queuedState = state;
-                        }
-                    }
-                    break;
-                case AnimationState.Reverting:
-                    if (state !== this._state) {
-                        if (state === this._nextState) {
-                            this._animationState = AnimationState.Transitioning;
-                            this._animator
-                                .animate({ value: 1 }, { duration: (1 - this._animatedObject.value) * this._options.duration })
-                                .tap(() => this._onComplete())
-                                .attach(this);
-                        }
-                        else {
-                            this._queuedState = state;
-                        }
-                    }
-                    break;
-            }
-        }
-    }
-    _onComplete() {
-        switch (this._animationState) {
-            case AnimationState.Transitioning:
-                if (this._animatedObject.value === 1) {
-                    this._animatedObject.value = 0;
-                    if (this._queuedState !== undefined) {
-                        this._animationState = AnimationState.Transitioning;
-                        this._state = this._nextState;
-                        this._nextState = this._queuedState;
-                        this._queuedState = undefined;
-                        this._onStateChangeAction.trigger({ state: this._state, nextState: this._nextState });
-                        this._animator
-                            .animate({ value: 1 })
-                            .tap(() => this._onComplete())
-                            .attach(this);
-                    }
-                    else {
-                        this._animationState = AnimationState.Idle;
-                        this._state = this._nextState;
-                        this._nextState = undefined;
-                        this._onStateChangeAction.trigger({ state: this._state, nextState: this._nextState });
-                    }
-                    this._onValueChangeAction.trigger(this._animatedObject.value);
-                }
-                break;
-            case AnimationState.Reverting:
-                if (this._state === undefined) {
-                    throw new Error('StateAnimation: state must be defined when reverting!');
-                }
-                if (this._animatedObject.value === 0) {
-                    if (this._queuedState !== undefined) {
-                        this._animationState = AnimationState.Transitioning;
-                        this._nextState = this._queuedState;
-                        this._queuedState = undefined;
-                        this._animatedObject.value = 0;
-                        this._onStateChangeAction.trigger({ state: this._state, nextState: this._nextState });
-                        this._animator
-                            .animate({ value: 1 })
-                            .tap(() => this._onComplete())
-                            .attach(this);
-                    }
-                    else {
-                        this._animationState = AnimationState.Idle;
-                        this._nextState = undefined;
-                        this._animatedObject.value = 0;
-                        this._onStateChangeAction.trigger({ state: this._state, nextState: this._nextState });
-                    }
-                    this._onValueChangeAction.trigger(this._animatedObject.value);
-                }
-                break;
-            case AnimationState.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/content-animations/slide/state-animation.test.d.ts

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