bard-legends-framework 0.11.0 → 0.12.1

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

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../../game-entities");
+const fade_in_state_animation_1 = require("./fade-in-state-animation");
+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 = {}));
+(0, vitest_1.describe)('FadeInStateAnimation', () => {
+    let heap = [];
+    let stateAnimation;
+    (0, vitest_1.beforeEach)(async () => {
+        if (stateAnimation) {
+            stateAnimation.destroy();
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+        }
+        heap = [];
+        stateAnimation = new fade_in_state_animation_1.FadeInStateAnimation({ duration: 4 })
+            .onStateChange(state => heap.push(state))
+            .onValueChange(value => heap.push(value))
+            .attachToRoot();
+    });
+    (0, vitest_1.describe)('Appearing', () => {
+        (0, vitest_1.test)('default values', () => {
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Hidden
+            });
+        });
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState('A');
+            (0, vitest_1.expect)(heap).toEqual(['A']);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('animation in the middle', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual(['A', 0.25]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.25,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('animation end', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(heap).toEqual(['A', 1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('instant once', async () => {
+            stateAnimation.setState('A', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual(['A', 1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('instant twice', async () => {
+            stateAnimation.setState('A', { instant: true });
+            heap = [];
+            stateAnimation.setState('A', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+    });
+    (0, vitest_1.describe)('Disappearing', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setState('A', { instant: true });
+            heap = [];
+        });
+        (0, vitest_1.test)('initial values', async () => {
+            stateAnimation.setState(undefined);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Disappearing
+            });
+        });
+        (0, vitest_1.test)('animation in the middle', async () => {
+            stateAnimation.setState(undefined);
+            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',
+                queuedState: undefined,
+                animationState: AnimationState.Disappearing
+            });
+        });
+        (0, vitest_1.test)('animation end', async () => {
+            stateAnimation.setState(undefined);
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Hidden
+            });
+        });
+        (0, vitest_1.test)('instant', async () => {
+            stateAnimation.setState(undefined, { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Hidden
+            });
+        });
+    });
+    (0, vitest_1.describe)('Cancel appearing', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+        });
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState(undefined);
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Disappearing
+            });
+        });
+        (0, vitest_1.test)('animation end', async () => {
+            stateAnimation.setState(undefined);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Hidden
+            });
+        });
+        (0, vitest_1.test)('instant', async () => {
+            stateAnimation.setState(undefined, { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: undefined,
+                queuedState: undefined,
+                animationState: AnimationState.Hidden
+            });
+        });
+    });
+    (0, vitest_1.describe)('Cancel disappearing', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            stateAnimation.setState(undefined);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            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.5,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('animation end', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            (0, vitest_1.expect)(heap).toEqual([1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('instant', async () => {
+            stateAnimation.setState('A', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual([1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('callbacks', async () => {
+            let stateChangeCalledWith = 'unset';
+            let valueChangeCalledWith = 'unset';
+            stateAnimation
+                .onStateChange(state => {
+                stateChangeCalledWith = state;
+            })
+                .onValueChange(value => {
+                valueChangeCalledWith = value;
+            });
+            stateAnimation.setState('A');
+            (0, vitest_1.expect)(stateChangeCalledWith).toBe('unset');
+            (0, vitest_1.expect)(valueChangeCalledWith).toBe('unset');
+            stateChangeCalledWith = 'unset';
+            valueChangeCalledWith = 'unset';
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateChangeCalledWith).toBe('unset');
+            (0, vitest_1.expect)(valueChangeCalledWith).toBe(0.75);
+            stateChangeCalledWith = 'unset';
+            valueChangeCalledWith = 'unset';
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(stateChangeCalledWith).toBe('unset');
+            (0, vitest_1.expect)(valueChangeCalledWith).toBe(1);
+        });
+    });
+    (0, vitest_1.describe)('Disappear to change', () => {
+        (0, vitest_1.beforeEach)(async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            heap = [];
+        });
+        (0, vitest_1.test)('initial values', async () => {
+            stateAnimation.setState('B');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: 'B',
+                animationState: AnimationState.DisappearToChange
+            });
+        });
+        (0, vitest_1.test)('dissapear animation in the middle', async () => {
+            stateAnimation.setState('B');
+            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',
+                queuedState: 'B',
+                animationState: AnimationState.DisappearToChange
+            });
+        });
+        (0, vitest_1.test)('dissapear animation end', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(heap).toEqual(['B', 0]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('appear animation in the middle', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual(['B', 0, 0.25]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.25,
+                state: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('appear animation end', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(heap).toEqual(['B', 0, 1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('returning back to the original state', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual([0.75, 1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('edge case, changing the decition back at the moment of re-appearing', async () => {
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            (0, vitest_1.expect)(heap).toEqual(['B', 0, 'A', 0.25]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.25,
+                state: 'A',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('instant', async () => {
+            stateAnimation.setState('B', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual(['B', 1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'B',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+    });
+    (0, vitest_1.describe)('Nullish State', () => {
+        (0, vitest_1.test)('initial values', () => {
+            stateAnimation.setState('');
+            (0, vitest_1.expect)(heap).toEqual(['']);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0,
+                state: '',
+                queuedState: undefined,
+                animationState: AnimationState.Appearing
+            });
+        });
+        (0, vitest_1.test)('instant', () => {
+            stateAnimation.setState('', { instant: true });
+            (0, vitest_1.expect)(heap).toEqual(['', 1]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: '',
+                queuedState: undefined,
+                animationState: AnimationState.Visible
+            });
+        });
+        (0, vitest_1.test)('Cancel appearing', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setState('');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'A',
+                queuedState: '',
+                animationState: AnimationState.DisappearToChange
+            });
+        });
+        (0, vitest_1.test)('Cancel disappearing', async () => {
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            stateAnimation.setState(undefined);
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setState('');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'A',
+                queuedState: '',
+                animationState: AnimationState.DisappearToChange
+            });
+        });
+        (0, vitest_1.test)('Disappear to change', () => {
+            stateAnimation.setState('A', { instant: true });
+            heap = [];
+            stateAnimation.setState('');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 1,
+                state: 'A',
+                queuedState: '',
+                animationState: AnimationState.DisappearToChange
+            });
+        });
+        (0, vitest_1.test)('Change disappear to change', async () => {
+            stateAnimation.setState('A', { instant: true });
+            stateAnimation.setState('B');
+            game_entities_1.UpdateCycle.triggerUpdateTick(2);
+            heap = [];
+            stateAnimation.setState('');
+            (0, vitest_1.expect)(heap).toEqual([]);
+            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
+                value: 0.5,
+                state: 'A',
+                queuedState: '',
+                animationState: AnimationState.DisappearToChange
+            });
+        });
+    });
+    (0, vitest_1.describe)('Error Cases:', () => {
+        (0, vitest_1.test)('completion on hidden state', async () => {
+            let consoleErrorSpy = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+            stateAnimation.setState('A');
+            stateAnimation.setState(undefined);
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(consoleErrorSpy).not.toBeCalled();
+            consoleErrorSpy.mockRestore();
+        });
+        (0, vitest_1.test)('completion on visible state', async () => {
+            let consoleErrorSpy = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            stateAnimation.setState(undefined);
+            stateAnimation.setState('A');
+            game_entities_1.UpdateCycle.triggerUpdateTick(4);
+            (0, vitest_1.expect)(consoleErrorSpy).not.toBeCalled();
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});
+//# sourceMappingURL=fade-in-state-animation.test.js.map

package/dist/utilities/animator/content-animations/slide/slide-in-content.d.ts

@@ -0,0 +1,41 @@
+import { Vector } from 'helpers-lib';
+import { Container } from '../../../../pixi/display-object/container';
+import { AnimatorAnimation } from '../../animations';
+export declare enum ScrollDirection {
+    Horizontal = 1,
+    Vertical = 2
+}
+export interface ScrollInContentOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly size: Vector;
+    readonly margin: number;
+    readonly direction: ScrollDirection;
+}
+export declare class SlideInContentByIndex extends Container {
+    private _createFunction;
+    private _options;
+    private _directionProperty;
+    private _stateAnimation;
+    private _contents;
+    constructor(_createFunction: (value: {
+        index: number;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setIndex(index: number, options?: {
+        instant?: boolean;
+    }): this;
+    private _createMask;
+}
+export declare class SlideInContent<T> extends SlideInContentByIndex {
+    readonly itemToIndex: Map<T, number>;
+    readonly indexToItem: Map<number, T>;
+    constructor(items: T[], createFunction: (value: {
+        index: number;
+        item: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setItem(item: T, options?: {
+        instant?: boolean;
+    }): this;
+}

package/dist/utilities/animator/content-animations/slide/slide-in-content.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlideInContent = exports.SlideInContentByIndex = exports.ScrollDirection = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const scroll_mask_ui_1 = require("../../../../pixi/components/scroll-mask.ui");
+const container_1 = require("../../../../pixi/display-object/container");
+const animations_1 = require("../../animations");
+const slide_state_animation_1 = require("./slide-state-animation");
+var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection[ScrollDirection["Horizontal"] = 1] = "Horizontal";
+    ScrollDirection[ScrollDirection["Vertical"] = 2] = "Vertical";
+})(ScrollDirection || (exports.ScrollDirection = ScrollDirection = {}));
+class SlideInContentByIndex extends container_1.Container {
+    constructor(_createFunction, partialOptions) {
+        super();
+        this._createFunction = _createFunction;
+        this._directionProperty = 'x';
+        this._contents = new Map();
+        this._options = {
+            duration: 300,
+            animation: animations_1.Animations.easeInOutCubic,
+            size: new helpers_lib_1.Vector(500, 500),
+            margin: 20,
+            direction: ScrollDirection.Horizontal,
+            ...partialOptions
+        };
+        let fullSize = this._options.direction === ScrollDirection.Horizontal
+            ? new helpers_lib_1.Vector(this._options.size.x + this._options.margin * 2, this._options.size.y)
+            : new helpers_lib_1.Vector(this._options.size.x, this._options.size.y + this._options.margin * 2);
+        let wrapper = new container_1.Container()
+            .setPosition(this._options.direction === ScrollDirection.Horizontal
+            ? new helpers_lib_1.Vector(-this._options.margin, 0)
+            : new helpers_lib_1.Vector(0, -this._options.margin), { round: false })
+            .displayParent(this)
+            .attach(this);
+        this._createMask(fullSize, this._options.margin, this._options.direction, wrapper);
+        this._directionProperty = this._options.direction === ScrollDirection.Horizontal ? 'x' : 'y';
+        this._stateAnimation = new slide_state_animation_1.SlideStateAnimation({
+            duration: this._options.duration,
+            animation: this._options.animation
+        })
+            .onStateChange((state, index) => {
+            if (state === slide_state_animation_1.SlideStateAnimationState.Appear) {
+                let container = new container_1.Container().displayParent(this).attach(this);
+                this._contents.set(index, container);
+                this._createFunction({ index, container });
+            }
+            else {
+                let container = this._contents.get(index);
+                if (container) {
+                    container.destroy();
+                    this._contents.delete(index);
+                }
+            }
+        })
+            .onValueChange((value, index) => {
+            let container = this._contents.get(index);
+            if (container) {
+                let vec = { x: 0, y: 0 };
+                vec[this._directionProperty] = fullSize[this._directionProperty] * value + this._options.margin;
+                container.setPosition(helpers_lib_1.Vector.fromVec2(vec), { round: false });
+            }
+        })
+            .attach(this);
+        this.addChildTo = wrapper;
+    }
+    setIndex(index, options) {
+        this._stateAnimation.setIndex(index, options);
+        return this;
+    }
+    _createMask(size, padding, direction, container) {
+        new scroll_mask_ui_1.ScrollMaskUI(container, new helpers_lib_1.Vector(size.x, size.y), padding, direction).attach(this);
+    }
+}
+exports.SlideInContentByIndex = SlideInContentByIndex;
+class SlideInContent extends SlideInContentByIndex {
+    constructor(items, createFunction, partialOptions) {
+        super((value) => {
+            let item = this.indexToItem.get(value.index);
+            if (item) {
+                createFunction({ index: value.index, item, container: value.container });
+            }
+            else {
+                throw new Error(`SlideInContent: The item with index '${value.index}' is not part of the items list`);
+            }
+        }, partialOptions);
+        this.itemToIndex = new Map();
+        this.indexToItem = new Map();
+        items.forEach((item, index) => {
+            this.itemToIndex.set(item, index);
+            this.indexToItem.set(index, item);
+        });
+    }
+    setItem(item, options) {
+        let index = this.itemToIndex.get(item);
+        if (index !== undefined) {
+            this.setIndex(index, options);
+        }
+        else {
+            throw new Error(`SlideInContent: The item '${item}' is not part of the items list`);
+        }
+        return this;
+    }
+}
+exports.SlideInContent = SlideInContent;
+//# sourceMappingURL=slide-in-content.js.map

package/dist/utilities/animator/content-animations/slide/slide-in-content.test.d.ts

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

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

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

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

@@ -0,0 +1,24 @@
+import { Attachable } from 'actions-lib';
+import { StateAnimationOptions } from './state-animation';
+export declare enum SlideStateAnimationState {
+    Appear = 1,
+    Disappear = 2
+}
+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;
+}