bard-legends-framework 0.11.0 → 0.12.0

package/dist/utilities/animator/content-animations/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/content-animations/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/content-animations/fade-in/fade-in-content.test.d.ts

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

package/dist/utilities/animator/content-animations/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/content-animations/fade-in/fade-in-state-animation.d.ts

@@ -0,0 +1,38 @@
+import { Attachable } from 'actions-lib';
+import { StateAnimationOptions } from '../slide/state-animation';
+declare enum AnimationState {
+    Hidden = 1,
+    Visible = 2,
+    Appearing = 3,
+    Disappearing = 4,
+    DisappearToChange = 5
+}
+export declare class FadeInStateAnimation<T> extends Attachable {
+    private _animator;
+    private _options;
+    private _animatedObject;
+    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/content-animations/fade-in/fade-in-state-animation.js

@@ -0,0 +1,208 @@
+"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");
+var AnimationState;
+(function (AnimationState) {
+    AnimationState[AnimationState["Hidden"] = 1] = "Hidden";
+    AnimationState[AnimationState["Visible"] = 2] = "Visible";
+    AnimationState[AnimationState["Appearing"] = 3] = "Appearing";
+    AnimationState[AnimationState["Disappearing"] = 4] = "Disappearing";
+    AnimationState[AnimationState["DisappearToChange"] = 5] = "DisappearToChange";
+})(AnimationState || (AnimationState = {}));
+class FadeInStateAnimation extends actions_lib_1.Attachable {
+    get currentState() {
+        return {
+            value: this._animatedObject.value,
+            state: this._state,
+            queuedState: this._queuedState,
+            animationState: this._animationState
+        };
+    }
+    constructor(partialOptions) {
+        super();
+        this._animatedObject = { value: 0 };
+        this._animationState = 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._animatedObject.value = 0;
+        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);
+    }
+    /**
+     * @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.completeAnimation();
+            this._animationState = state !== undefined ? AnimationState.Visible : AnimationState.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._animatedObject.value !== value) {
+                this._animatedObject.value = value;
+                this._onValueChangeAction.trigger(this._animatedObject.value);
+            }
+        }
+        else {
+            switch (this._animationState) {
+                case AnimationState.Hidden:
+                    if (state !== undefined) {
+                        this._animationState = AnimationState.Appearing;
+                        this._queuedState = undefined;
+                        this._state = state;
+                        this._onStateChangeAction.trigger(this._state);
+                        this._animator
+                            .animate({ value: 1 })
+                            .tap(() => this._onComplete())
+                            .attach(this);
+                    }
+                    break;
+                case AnimationState.Visible:
+                    if (state === undefined) {
+                        this._animationState = AnimationState.Disappearing;
+                        this._queuedState = undefined;
+                        this._animator
+                            .animate({ value: 0 })
+                            .tap(() => this._onComplete())
+                            .attach(this);
+                    }
+                    else if (state !== this._state) {
+                        this._animationState = AnimationState.DisappearToChange;
+                        this._queuedState = state;
+                        this._animator
+                            .animate({ value: 0 })
+                            .tap(() => this._onComplete())
+                            .attach(this);
+                    }
+                    break;
+                case AnimationState.Appearing:
+                    if (state === undefined) {
+                        this._animationState = AnimationState.Disappearing;
+                        this._queuedState = undefined;
+                        this._animator
+                            .animate({ value: 0 }, { duration: this._animatedObject.value * this._options.duration })
+                            .tap(() => this._onComplete())
+                            .attach(this);
+                    }
+                    else if (state !== this._state) {
+                        if (this._animatedObject.value > 0) {
+                            this._animationState = AnimationState.DisappearToChange;
+                            this._queuedState = state;
+                            this._animator
+                                .animate({ value: 0 }, { duration: this._animatedObject.value * this._options.duration })
+                                .tap(() => this._onComplete())
+                                .attach(this);
+                        }
+                        else {
+                            this._queuedState = undefined;
+                            this._state = state;
+                            this._onStateChangeAction.trigger(this._state);
+                        }
+                    }
+                    break;
+                case AnimationState.Disappearing:
+                    if (state === this._state) {
+                        this._animationState = AnimationState.Appearing;
+                        this._animator
+                            .animate({ value: 1 }, { duration: (1 - this._animatedObject.value) * this._options.duration })
+                            .tap(() => this._onComplete())
+                            .attach(this);
+                    }
+                    else if (state !== undefined) {
+                        this._animationState = AnimationState.DisappearToChange;
+                        this._queuedState = state;
+                    }
+                    break;
+                case AnimationState.DisappearToChange:
+                    if (state === undefined) {
+                        this._animationState = AnimationState.Disappearing;
+                        this._queuedState = undefined;
+                    }
+                    else if (state === this._state) {
+                        this._animationState = AnimationState.Appearing;
+                        this._queuedState = undefined;
+                        this._animator
+                            .animate({ value: 1 }, { duration: (1 - this._animatedObject.value) * this._options.duration })
+                            .tap(() => this._onComplete())
+                            .attach(this);
+                    }
+                    else if (state !== this._queuedState) {
+                        this._queuedState = state;
+                    }
+                    break;
+            }
+        }
+    }
+    _onComplete() {
+        switch (this._animationState) {
+            case AnimationState.Appearing:
+                if (this._animatedObject.value === 1) {
+                    this._animationState = AnimationState.Visible;
+                    this._onValueChangeAction.trigger(this._animatedObject.value);
+                }
+                break;
+            case AnimationState.Disappearing:
+                if (this._queuedState !== undefined) {
+                    throw new Error('FadeInStateAnimation: Unexpected state, disappearing should not have a queued value');
+                }
+                if (this._animatedObject.value === 0) {
+                    this._animationState = AnimationState.Hidden;
+                    this._state = undefined;
+                    this._onStateChangeAction.trigger(this._state);
+                    this._onValueChangeAction.trigger(this._animatedObject.value);
+                }
+                break;
+            case AnimationState.DisappearToChange:
+                if (this._queuedState === undefined) {
+                    throw new Error('FadeInStateAnimation: Unexpected state, disappearToChange should always have a queued value');
+                }
+                if (this._animatedObject.value === 0) {
+                    this._animationState = AnimationState.Appearing;
+                    this._state = this._queuedState;
+                    this._queuedState = undefined;
+                    this._onStateChangeAction.trigger(this._state);
+                    this._onValueChangeAction.trigger(this._animatedObject.value);
+                    this._animator
+                        .animate({ value: 1 })
+                        .tap(() => this._onComplete())
+                        .attach(this);
+                }
+                break;
+            case AnimationState.Hidden:
+            case AnimationState.Visible:
+                // Do nothing
+                return;
+        }
+    }
+    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/content-animations/fade-in/fade-in-state-animation.test.d.ts

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