bard-legends-framework 0.12.1 → 1.0.0-rc0

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

@@ -1,37 +0,0 @@
-import { Vector } from 'helpers-lib';
-import { Container } from '../../../pixi';
-import { AnimatorAnimation } from '../animations';
-export interface ScrollInContentOptions {
-    readonly duration: number;
-    readonly animation: AnimatorAnimation;
-    readonly size: Vector;
-    readonly margin: number;
-    readonly direction: 'horizontal' | 'vertical';
-}
-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/animating-content/slide-in-content.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlideInContent = exports.SlideInContentByIndex = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const pixi_1 = require("../../../pixi");
-const animations_1 = require("../animations");
-const slide_state_animation_1 = require("../state-animation/slide-state-animation");
-class SlideInContentByIndex extends pixi_1.Container {
-    constructor(createFunction, partialOptions) {
-        super();
-        this.createFunction = createFunction;
-        this.directionProperty = 'x';
-        this.contents = new Map();
-        this.options = {
-            duration: 300,
-            animation: new animations_1.AnimationEaseInOutCubic(),
-            size: new helpers_lib_1.Vector(500, 500),
-            margin: 20,
-            direction: 'horizontal',
-            ...partialOptions
-        };
-        let fullSize = this.options.direction === '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 pixi_1.Container()
-            .setPosition(this.options.direction === '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 === '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 pixi_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 pixi_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/animating-content/slide-in-content.test.d.ts

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

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

@@ -1,10 +0,0 @@
-"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/animations.d.ts

@@ -1,45 +0,0 @@
-export interface AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-export declare class AnimationInterpolationFunctions {
-    static boomerangTime(time: number): number;
-    static lineer(time: number): number;
-    static easeIn(time: number): number;
-    static easeOut(time: number): number;
-    static easeInOut(time: number): number;
-    static easeInOutCubic(t: number): number;
-}
-declare class AnimationLineer implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-declare class AnimationEaseIn implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-declare class AnimationEaseOut implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-declare class AnimationEaseInOut implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-declare class AnimationEaseInOutCubic implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-export declare class AnimationFlicker implements AnimatorAnimation {
-    private _timeGrid;
-    start(): void;
-    multiplierFunction(t: number): number;
-}
-export declare class Animations {
-    static lineer: AnimationLineer;
-    static easeIn: AnimationEaseIn;
-    static easeOut: AnimationEaseOut;
-    static easeInOut: AnimationEaseInOut;
-    static easeInOutCubic: AnimationEaseInOutCubic;
-}
-export {};

package/dist/utilities/animator/animations.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Animations = exports.AnimationFlicker = exports.AnimationInterpolationFunctions = void 0;
-const helpers_lib_1 = require("helpers-lib");
-class AnimationInterpolationFunctions {
-    static boomerangTime(time) {
-        return 1 - Math.abs(time - 0.5) * 2;
-    }
-    static lineer(time) {
-        return time;
-    }
-    static easeIn(time) {
-        return Math.pow(time, 2);
-    }
-    static easeOut(time) {
-        return 1 - Math.pow(1 - time, 2);
-    }
-    static easeInOut(time) {
-        if (time < 0.5) {
-            return 2 * time * time;
-        }
-        else {
-            time -= 1;
-            return 1 - 2 * time * time;
-        }
-    }
-    static easeInOutCubic(t) {
-        let a = 2 * t - 2;
-        return t < 0.5 ? 4 * Math.pow(t, 3) : (t - 1) * Math.pow(a, 2) + 1;
-    }
-}
-exports.AnimationInterpolationFunctions = AnimationInterpolationFunctions;
-class AnimationLineer {
-    start() { }
-    multiplierFunction(t) {
-        return AnimationInterpolationFunctions.lineer(t);
-    }
-}
-class AnimationEaseIn {
-    start() { }
-    multiplierFunction(t) {
-        return AnimationInterpolationFunctions.easeIn(t);
-    }
-}
-class AnimationEaseOut {
-    start() { }
-    multiplierFunction(t) {
-        return AnimationInterpolationFunctions.easeOut(t);
-    }
-}
-class AnimationEaseInOut {
-    start() { }
-    multiplierFunction(t) {
-        return AnimationInterpolationFunctions.easeInOut(t);
-    }
-}
-class AnimationEaseInOutCubic {
-    start() { }
-    multiplierFunction(t) {
-        return AnimationInterpolationFunctions.easeInOutCubic(t);
-    }
-}
-// Because AnimationFlicker is holding a state "timeGrid", it has to be a seperate instance on where it is used
-class AnimationFlicker {
-    start() {
-        this._timeGrid = new Array(10).fill(0);
-        helpers_lib_1.Random.integerBetween(0, 9);
-        this._timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
-        if (Math.random() < 0.3) {
-            helpers_lib_1.Random.integerBetween(0, 9);
-            this._timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
-        }
-        if (Math.random() < 0.2) {
-            helpers_lib_1.Random.integerBetween(0, 9);
-            this._timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
-        }
-    }
-    multiplierFunction(t) {
-        let index = Math.floor(t * 10);
-        return this._timeGrid[index];
-    }
-}
-exports.AnimationFlicker = AnimationFlicker;
-class Animations {
-    static { this.lineer = new AnimationLineer(); }
-    static { this.easeIn = new AnimationEaseIn(); }
-    static { this.easeOut = new AnimationEaseOut(); }
-    static { this.easeInOut = new AnimationEaseInOut(); }
-    static { this.easeInOutCubic = new AnimationEaseInOutCubic(); }
-}
-exports.Animations = Animations;
-//# sourceMappingURL=animations.js.map

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

@@ -1,44 +0,0 @@
-import { Notifier, SingleEvent } from 'actions-lib';
-import { AnimatorAnimation } from '../animations';
-export declare enum ReAnimateHandlingType {
-    ThrowError = 1,
-    IgnoreNewAnimation = 2,
-    CompletePrevious = 3
-}
-export declare enum AnimationsCompletionHandlingType {
-    ReturnToOriginal = 1,
-    StayInCurrentState = 2,
-    JumpToEnd = 3,
-    Loop = 4
-}
-export interface AnimationOptions {
-    readonly duration: number;
-    readonly animation: AnimatorAnimation;
-    readonly reAnimateHandling: ReAnimateHandlingType;
-    readonly completionHandling: AnimationsCompletionHandlingType;
-}
-type NumericKeys<T> = {
-    [P in keyof T]: T[P] extends number ? P : never;
-}[keyof T] & string;
-export declare class Animator<T extends object = any, K extends NumericKeys<T> = NumericKeys<T>> {
-    private static _animatedObjects;
-    private static _getAnimatedObjectProperties;
-    private _target;
-    private _options;
-    private _animatedProperties;
-    private _ongoingAnimation;
-    get animating(): boolean;
-    get target(): T;
-    private _value;
-    get value(): Notifier<T>;
-    constructor(target: T & Record<K, number>, animatedProperties: K | K[], partialOptions?: Partial<AnimationOptions>);
-    animate(values: Record<K, number>, partialOptions?: Partial<AnimationOptions>): SingleEvent<void>;
-    set(values: Record<K, number>): void;
-    completeAnimation(completionHandling?: AnimationsCompletionHandlingType): void;
-    private _isAnimatingToSameValues;
-    private _setCompletionValues;
-    private _returnToStartingValues;
-    private _jumpToTargetValues;
-    private _lockAnimatedProperties;
-}
-export {};

package/dist/utilities/animator/animator/animator.js

@@ -1,234 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Animator = exports.AnimationsCompletionHandlingType = exports.ReAnimateHandlingType = void 0;
-const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
-const game_entities_1 = require("../../../game-entities");
-const animations_1 = require("../animations");
-var ReAnimateHandlingType;
-(function (ReAnimateHandlingType) {
-    ReAnimateHandlingType[ReAnimateHandlingType["ThrowError"] = 1] = "ThrowError";
-    ReAnimateHandlingType[ReAnimateHandlingType["IgnoreNewAnimation"] = 2] = "IgnoreNewAnimation";
-    ReAnimateHandlingType[ReAnimateHandlingType["CompletePrevious"] = 3] = "CompletePrevious";
-})(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
-var AnimationsCompletionHandlingType;
-(function (AnimationsCompletionHandlingType) {
-    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["ReturnToOriginal"] = 1] = "ReturnToOriginal";
-    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["StayInCurrentState"] = 2] = "StayInCurrentState";
-    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["JumpToEnd"] = 3] = "JumpToEnd";
-    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["Loop"] = 4] = "Loop";
-})(AnimationsCompletionHandlingType || (exports.AnimationsCompletionHandlingType = AnimationsCompletionHandlingType = {}));
-class Animator {
-    static { this._animatedObjects = new WeakMap(); }
-    static _getAnimatedObjectProperties(target) {
-        let animatedObjectProperties = Animator._animatedObjects.get(target);
-        if (!animatedObjectProperties) {
-            animatedObjectProperties = new helpers_lib_1.MapToWeakRefs();
-            Animator._animatedObjects.set(target, animatedObjectProperties);
-        }
-        return animatedObjectProperties;
-    }
-    get animating() {
-        return this._ongoingAnimation !== undefined;
-    }
-    get target() {
-        return this._target;
-    }
-    get value() {
-        if (!this._value) {
-            this._value = new actions_lib_1.Variable(this._target);
-        }
-        return this._value.notifier;
-    }
-    constructor(target, animatedProperties, partialOptions) {
-        this._target = target;
-        this._options = {
-            duration: 200,
-            animation: animations_1.Animations.lineer,
-            reAnimateHandling: ReAnimateHandlingType.ThrowError,
-            completionHandling: AnimationsCompletionHandlingType.StayInCurrentState,
-            ...partialOptions
-        };
-        this._animatedProperties = helpers_lib_1.Comparator.isArray(animatedProperties) ? animatedProperties : [animatedProperties];
-        this._lockAnimatedProperties(target, this._animatedProperties); // NOTE: this can be removed in release mode
-    }
-    animate(values, partialOptions) {
-        let options = {
-            ...this._options,
-            ...partialOptions
-        };
-        if (this._ongoingAnimation) {
-            switch (options.reAnimateHandling) {
-                case ReAnimateHandlingType.ThrowError:
-                    throw new Error(`Animator: new animation triggered while another is not complete yet.`);
-                case ReAnimateHandlingType.IgnoreNewAnimation:
-                    return actions_lib_1.SingleEvent.instant();
-                case ReAnimateHandlingType.CompletePrevious:
-                    this._setCompletionValues(options.completionHandling, this._ongoingAnimation._properties, true);
-                    break;
-                default: {
-                    let _ = options.reAnimateHandling;
-                    throw new Error(`Animator: unknown re-animate handling type: "${options.reAnimateHandling}"`);
-                }
-            }
-        }
-        let event = actions_lib_1.SingleEvent.create(resolve => {
-            let properties = this._animatedProperties.reduce((acc, key) => {
-                acc[key] = {
-                    _startingValue: this._target[key],
-                    _targetValue: values[key]
-                };
-                return acc;
-            }, {});
-            let updateCycleSubscription;
-            let animationState = {
-                _duration: options.duration,
-                _elapsedTime: 0,
-                _properties: properties,
-                _completionHandling: options.completionHandling,
-                _animation: options.animation,
-                _completionCallback: resolve
-            };
-            if (animationState._completionHandling !== AnimationsCompletionHandlingType.Loop &&
-                this._isAnimatingToSameValues(animationState)) {
-                this._ongoingAnimation = undefined;
-                resolve();
-                return;
-            }
-            else {
-                animationState._animation.start();
-            }
-            let previousAnimationState = this._ongoingAnimation;
-            this._ongoingAnimation = animationState;
-            updateCycleSubscription = game_entities_1.UpdateCycle.beforeSceneUpdateAction
-                .subscribe(update => {
-                animationState._elapsedTime += update.delta;
-                let animationIsCompete = animationState._elapsedTime >= animationState._duration;
-                if (animationIsCompete) {
-                    if (animationState._completionHandling === AnimationsCompletionHandlingType.Loop) {
-                        animationState._elapsedTime %= animationState._duration;
-                        animationState._animation.start();
-                        animationIsCompete = false;
-                    }
-                    else {
-                        this._setCompletionValues(animationState._completionHandling, animationState._properties, false);
-                        this._ongoingAnimation = undefined;
-                        animationState._completionCallback();
-                    }
-                }
-                if (!animationIsCompete) {
-                    let multiplier = animationState._animation.multiplierFunction(animationState._elapsedTime / animationState._duration);
-                    let changeHappened = false;
-                    for (let i = 0; i < this._animatedProperties.length; i++) {
-                        let key = this._animatedProperties[i];
-                        let propertyState = animationState._properties[key];
-                        let relativeTarget = propertyState._targetValue - propertyState._startingValue;
-                        let newValue = relativeTarget * multiplier + propertyState._startingValue;
-                        if (newValue !== this._target[key]) {
-                            changeHappened = true;
-                            this._target[key] = newValue;
-                        }
-                    }
-                    changeHappened && this._value?.set(this._target);
-                }
-            })
-                .attachToRoot();
-            previousAnimationState?._completionCallback();
-            return () => {
-                updateCycleSubscription.destroy();
-                if (this._ongoingAnimation === animationState) {
-                    if (!(this._target instanceof actions_lib_1.Attachable && this._target.destroyed)) {
-                        this._setCompletionValues(this._ongoingAnimation._completionHandling, this._ongoingAnimation._properties, true);
-                    }
-                    this._ongoingAnimation = undefined;
-                }
-            };
-        });
-        return event;
-    }
-    set(values) {
-        let changeHappened = false;
-        for (let i = 0; i < this._animatedProperties.length; i++) {
-            let key = this._animatedProperties[i];
-            if (this._target[key] !== values[key]) {
-                changeHappened = true;
-                this._target[key] = values[key];
-            }
-        }
-        changeHappened && this._value?.set(this._target);
-        this._ongoingAnimation?._completionCallback();
-    }
-    completeAnimation(completionHandling) {
-        if (this._ongoingAnimation) {
-            completionHandling = completionHandling ?? this._ongoingAnimation._completionHandling;
-            this._setCompletionValues(completionHandling, this._ongoingAnimation._properties, true);
-            let callback = this._ongoingAnimation._completionCallback;
-            this._ongoingAnimation = undefined;
-            callback();
-        }
-    }
-    _isAnimatingToSameValues(ongoingAnimation) {
-        for (let i = 0; i < this._animatedProperties.length; i++) {
-            let key = this._animatedProperties[i];
-            if (this._target[key] !== ongoingAnimation._properties[key]._targetValue) {
-                return false;
-            }
-        }
-        return true;
-    }
-    _setCompletionValues(completionHandling, values, interruptedCompletion) {
-        switch (completionHandling) {
-            case AnimationsCompletionHandlingType.ReturnToOriginal:
-                this._returnToStartingValues(values);
-                break;
-            case AnimationsCompletionHandlingType.StayInCurrentState:
-                if (!interruptedCompletion) {
-                    this._jumpToTargetValues(values);
-                }
-                break;
-            case AnimationsCompletionHandlingType.JumpToEnd:
-                this._jumpToTargetValues(values);
-                break;
-            case AnimationsCompletionHandlingType.Loop:
-                this._returnToStartingValues(values);
-                break;
-            default: {
-                let _ = completionHandling;
-                throw new Error(`Animator: unknown completion handling type: "${completionHandling}"`);
-            }
-        }
-    }
-    _returnToStartingValues(values) {
-        let changeHappened = false;
-        for (let i = 0; i < this._animatedProperties.length; i++) {
-            let key = this._animatedProperties[i];
-            if (this._target[key] !== values[key]._startingValue) {
-                changeHappened = true;
-                this._target[key] = values[key]._startingValue;
-            }
-        }
-        changeHappened && this._value?.set(this._target);
-    }
-    _jumpToTargetValues(values) {
-        let changeHappened = false;
-        for (let i = 0; i < this._animatedProperties.length; i++) {
-            let key = this._animatedProperties[i];
-            if (this._target[key] !== values[key]._targetValue) {
-                changeHappened = true;
-                this._target[key] = values[key]._targetValue;
-            }
-        }
-        changeHappened && this._value?.set(this._target);
-    }
-    _lockAnimatedProperties(target, animatedProperties) {
-        let animatedObjectProperties = Animator._getAnimatedObjectProperties(target);
-        for (let key of animatedProperties) {
-            if (animatedObjectProperties.has(key)) {
-                throw new Error(`Animator: target property is already animated! Target: "${JSON.stringify(target, undefined, 2)}", Property: "${key}"`);
-            }
-            animatedObjectProperties.set(key, this);
-        }
-    }
-}
-exports.Animator = Animator;
-//# sourceMappingURL=animator.js.map

package/dist/utilities/animator/animator/animator.memory-leak.test.d.ts

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

package/dist/utilities/animator/animator/animator.memory-leak.test.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@memlab/core");
-const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
-const vitest_1 = require("vitest");
-const game_entities_1 = require("../../../game-entities");
-const animator_1 = require("./animator");
-const ClassNamesToCheck = ['Animator', 'SingleEvent'];
-vitest_1.describe.skipIf(process.env.QUICK)('Memory Leak', () => {
-    (0, vitest_1.beforeEach)(() => {
-        actions_lib_1.ActionLib.hardReset();
-    });
-    async function checkMemoryLeaks(...additionalNames) {
-        await helpers_lib_1.UnitTestHelper.waitForAllOperations();
-        await (0, helpers_lib_1.Wait)();
-        let snapshot = await (0, core_1.takeNodeMinimalHeap)();
-        ClassNamesToCheck.concat(additionalNames).forEach(name => {
-            if (snapshot.hasObjectWithClassName(name)) {
-                throw new Error(`"${name}" has at least one instance in the memory.`);
-            }
-        });
-    }
-    (0, vitest_1.test)('simple animator', async () => {
-        let target = { x: 1 };
-        let animator = new animator_1.Animator(target, 'x');
-        (0, vitest_1.expect)(animator).toBeDefined();
-        animator = undefined;
-        await (0, vitest_1.expect)(checkMemoryLeaks()).resolves.not.toThrow();
-    }, 60000);
-    (0, vitest_1.test)('sample animation', async () => {
-        let target = { x: 1 };
-        let animator = new animator_1.Animator(target, 'x');
-        let animation = animator.animate({ x: 2 }).attachToRoot();
-        game_entities_1.UpdateCycle.triggerUpdateTick(1);
-        (0, vitest_1.expect)(animation).toBeDefined();
-        animation.destroy();
-        animator = undefined;
-        animation = undefined;
-        await (0, vitest_1.expect)(checkMemoryLeaks()).resolves.not.toThrow();
-    }, 60000);
-    (0, vitest_1.test)('target contains the animator', async () => {
-        class Foo {
-            constructor() {
-                this.x = 0;
-                this.animator = new animator_1.Animator(this, 'x');
-            }
-        }
-        let foo = new Foo();
-        (0, vitest_1.expect)(foo).toBeDefined();
-        foo = undefined;
-        await (0, vitest_1.expect)(checkMemoryLeaks(Foo.name)).resolves.not.toThrow();
-    }, 60000);
-    (0, vitest_1.test)('default animation contains the animator', async () => {
-        class FaultyAnimation {
-            start() { }
-            multiplierFunction(t) {
-                return 0;
-            }
-            setAnimator(anim) {
-                this._animator = anim;
-            }
-        }
-        let animation = new FaultyAnimation();
-        let animator = new animator_1.Animator({ x: 1 }, 'x', { animation });
-        animation.setAnimator(animator);
-        (0, vitest_1.expect)(animator).toBeDefined();
-        animation = undefined;
-        animator = undefined;
-        await (0, vitest_1.expect)(checkMemoryLeaks(FaultyAnimation.name)).resolves.not.toThrow();
-    }, 60000);
-});
-//# sourceMappingURL=animator.memory-leak.test.js.map

package/dist/utilities/animator/animator/animator.performance.test.d.ts

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