bard-legends-framework 0.11.0 → 0.12.1

package/dist/pixi/components/menu/menu.ui.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Menu = void 0;
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const utilities_1 = require("../../../utilities");
+const display_object_1 = require("../../display-object");
+const game_1 = require("../../game");
+class Menu extends display_object_1.Container {
+    static { this._transitioning = false; }
+    static closeAll() {
+        return Menu._openWindow ? Menu._openWindow.close() : actions_lib_1.SingleEvent.instant();
+    }
+    constructor(background, partialOptions) {
+        super();
+        this._onOpen = new actions_lib_1.SingleAction();
+        this.onOpen = this._onOpen.notifier;
+        this._onClose = new actions_lib_1.SingleAction();
+        this.onClose = this._onClose.notifier;
+        let options = {
+            closeOnBackgroundClick: true,
+            appearAnimationDuration: 150,
+            darkeningAlpha: 0.3,
+            ...partialOptions
+        };
+        this.setZIndex(100).setAlpha(0);
+        this._animator = new utilities_1.Animator(this, 'alpha', {
+            animation: utilities_1.Animations.easeInOutCubic,
+            duration: options.appearAnimationDuration,
+            reAnimateHandling: utilities_1.ReAnimateHandlingType.CompletePrevious,
+            completionHandling: utilities_1.AnimationsCompletionHandlingType.StayInCurrentState
+        });
+        this._background = display_object_1.Graphics.createRectangle(new helpers_lib_1.Vector(1, 1), helpers_lib_1.ColorHelper.black)
+            .toSprite({ cache: true })
+            .setAlpha(options.darkeningAlpha)
+            .setInteractive(true)
+            .displayParent(this)
+            .attach(this);
+        this._menu = display_object_1.Sprite.createByName(background)
+            .setPosition(new helpers_lib_1.Vector(0, 0))
+            .setInteractive(true)
+            .displayParent(this)
+            .attach(this);
+        game_1.Game.instance.screenSize
+            .subscribe(value => {
+            this._background.aspectRatio = value.x / value.y;
+            this._background.scale = Math.max(value.x, value.y);
+            this._background.setPosition(helpers_lib_1.Vector.zero, { holdFrom: helpers_lib_1.Vector.half });
+            this.setPosition(value.multiplyNumber(0.5));
+        })
+            .attach(this);
+        Menu._openWindow = this;
+        this.onDestroy()
+            .tap(() => {
+            Menu._openWindow = undefined;
+        })
+            .attachToRoot();
+        if (options.closeOnBackgroundClick) {
+            this._background
+                .on(display_object_1.ContainerEventType.Click, () => {
+                if (!Menu._transitioning) {
+                    this._appear(false);
+                }
+            })
+                .attach(this);
+        }
+        this._appear(true);
+    }
+    getBoundingMask() {
+        return this._menu.getBoundingMask();
+    }
+    close() {
+        return this._appear(false);
+    }
+    _appear(appear) {
+        if (Menu._transitioning) {
+            throw new Error('WindowUI: cannot iterate while in transition');
+        }
+        Menu._transitioning = true;
+        return this._animator
+            .animate({ alpha: appear ? 1 : 0 })
+            .chain(this)
+            .tap(() => {
+            Menu._transitioning = false;
+            if (appear) {
+                this._onOpen.resolve();
+            }
+            else {
+                this._onClose.resolve();
+                this.destroy();
+            }
+        })
+            .chainToRoot();
+    }
+}
+exports.Menu = Menu;
+//# sourceMappingURL=menu.ui.js.map

package/dist/pixi/components/mouse-wheel-listener.ui.d.ts

@@ -4,8 +4,8 @@ import { Container } from '../display-object/container';
 export declare class MouseWheelListenerUI extends Container {
     readonly _onWheel: Action<number>;
     readonly onWheel: import("actions-lib").Notifier<number>;
-    private wheelListener;
-    private handler;
+    private _wheelListener;
+    private _handler;
     constructor(size: Vector);
     destroy(): void;
 }

package/dist/pixi/components/mouse-wheel-listener.ui.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MouseWheelListenerUI = void 0;
 const actions_lib_1 = require("actions-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const game_entities_1 = require("../../game-entities");
 const container_1 = require("../display-object/container");
 const mouse_service_1 = require("../services/mouse/mouse.service");
@@ -34,9 +34,9 @@ class MouseWheelListenerUI extends container_1.Container {
         super();
         this._onWheel = new actions_lib_1.Action();
         this.onWheel = this._onWheel.notifier;
-        this.handler = ((event) => {
+        this._handler = ((event) => {
             let mouseScreenPosition = game_entities_1.Service.get(mouse_service_1.MouseService).getScreenPosition();
-            let bounds = this.wheelListener.getBounds();
+            let bounds = this._wheelListener.getBounds();
             if (mouseScreenPosition.x >= bounds.x &&
                 mouseScreenPosition.x <= bounds.x + bounds.width &&
                 mouseScreenPosition.y >= bounds.y &&
@@ -44,18 +44,18 @@ class MouseWheelListenerUI extends container_1.Container {
                 this._onWheel.trigger(event.deltaY);
             }
         }).bind(this);
-        this.wheelListener = new PIXI.Graphics();
-        this.wheelListener.beginFill(0x000000, 0.000000001);
-        this.wheelListener.drawRect(0, 0, size.x, size.y);
-        this.wheelListener.endFill();
-        this.pixiContainer.addChild(this.wheelListener);
-        window.addEventListener('wheel', this.handler);
+        this._wheelListener = new Pixi.Graphics();
+        this._wheelListener.beginFill(0x000000, 0.000000001);
+        this._wheelListener.drawRect(0, 0, size.x, size.y);
+        this._wheelListener.endFill();
+        this.pixiContainer.addChild(this._wheelListener);
+        window.addEventListener('wheel', this._handler);
     }
     destroy() {
         if (!this.destroyed) {
-            this.wheelListener.destroy();
-            window.removeEventListener('wheel', this.handler);
             super.destroy();
+            this._wheelListener.destroy();
+            window.removeEventListener('wheel', this._handler);
         }
     }
 }

package/dist/pixi/components/scroll-area.ui.d.ts

@@ -8,7 +8,7 @@ export interface ScrollingOptions {
     readonly instant: boolean;
 }
 export declare class ScrollAreaUI extends Container {
-    private scroller;
+    private _scroller;
     private _contentAreaSize;
     get contentAreaSize(): Vector;
     get contentSize(): Vector;

package/dist/pixi/components/scroll-area.ui.js

@@ -13,7 +13,7 @@ class ScrollAreaUI extends container_1.Container {
         return this._contentAreaSize;
     }
     get contentSize() {
-        return this.scroller.contentSize;
+        return this._scroller.contentSize;
     }
     constructor(scrollAreaSize, partialOptions = {}) {
         super();
@@ -32,23 +32,23 @@ class ScrollAreaUI extends container_1.Container {
         let wrapper = new container_1.Container().displayParent(this).attach(this);
         new scroll_mask_ui_1.ScrollMaskUI(wrapper, scrollAreaSize, options.padding).attach(this);
         let content = new container_1.Container().displayParent(wrapper).attach(this);
-        this.scroller = new smooth_scroller_1.SmoothScroller(content, scrollAreaSize.y, options.padding, options.smallContentAlign);
-        this._contentAreaSize = new helpers_lib_1.Vector(scrollAreaSize.x, this.scroller.scrollHeight);
+        this._scroller = new smooth_scroller_1.SmoothScroller(content, scrollAreaSize.y, options.padding, options.smallContentAlign);
+        this._contentAreaSize = new helpers_lib_1.Vector(scrollAreaSize.x, this._scroller.scrollHeight);
         let scrollArea = new mouse_wheel_listener_ui_1.MouseWheelListenerUI(scrollAreaSize).displayParent(wrapper).attach(this);
-        scrollArea.onWheel.subscribe(scrollDelta => this.scroller.onWheel(scrollDelta)).attach(this);
-        game_entities_1.UpdateCycle.afterSceneUpdateAction.subscribe(event => this.scroller.update(event.delta)).attach(this);
+        scrollArea.onWheel.subscribe(scrollDelta => this._scroller.onWheel(scrollDelta)).attach(this);
+        game_entities_1.UpdateCycle.afterSceneUpdateAction.subscribe(event => this._scroller.update(event.delta)).attach(this);
         this.addChildTo = content;
     }
     scrollToTop(options) {
-        this.scroller.scrollToTop();
+        this._scroller.scrollToTop();
         if (options?.instant) {
-            this.scroller.jumpToTarget();
+            this._scroller.jumpToTarget();
         }
     }
     scrollToBottom(options) {
-        this.scroller.scrollToBottom();
+        this._scroller.scrollToBottom();
         if (options?.instant) {
-            this.scroller.jumpToTarget();
+            this._scroller.jumpToTarget();
         }
     }
 }

package/dist/pixi/components/scroll-mask.ui.d.ts

@@ -1,16 +1,17 @@
 import { Vector } from 'helpers-lib';
-import { AnimatorAnimation } from '../../utilities';
+import { ScrollDirection } from '../../utilities';
+import { AnimatorAnimation } from '../../utilities/animator/animations';
 import { Container } from '../display-object/container';
 export declare class AnimationEaseInOutFlatter implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
 export declare class ScrollMaskUI extends Container {
-    private static drawnTextureCache;
-    private mask;
-    constructor(container: Container, size: Vector, padding: number, direction?: 'horizontal' | 'vertical');
-    private createVecticalMask;
-    private createHorizontalMask;
-    private createGradientSprite;
-    private createGradientTexture;
+    private static _drawnTextureCache;
+    private _maskSprite;
+    constructor(container: Container, size: Vector, padding: number, direction?: ScrollDirection);
+    private _createVecticalMask;
+    private _createHorizontalMask;
+    private _createGradientSprite;
+    private _createGradientTexture;
 }

package/dist/pixi/components/scroll-mask.ui.js

@@ -25,7 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScrollMaskUI = exports.AnimationEaseInOutFlatter = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
+const utilities_1 = require("../../utilities");
 const container_1 = require("../display-object/container");
 const graphics_1 = require("../display-object/objects/graphics/graphics");
 const sprite_1 = require("../display-object/objects/sprite/sprite");
@@ -38,8 +39,8 @@ class AnimationEaseInOutFlatter {
 }
 exports.AnimationEaseInOutFlatter = AnimationEaseInOutFlatter;
 class ScrollMaskUI extends container_1.Container {
-    static { this.drawnTextureCache = new Map(); }
-    constructor(container, size, padding, direction = 'vertical') {
+    static { this._drawnTextureCache = new Map(); }
+    constructor(container, size, padding, direction = utilities_1.ScrollDirection.Vertical) {
         super();
         if (padding < 0) {
             throw new Error(`The padding of the scroll mask cannot be lower than '0'`);
@@ -48,19 +49,19 @@ class ScrollMaskUI extends container_1.Container {
             throw new Error(`The height of the scroll mask cannot be lower than '${padding * 2}'`);
         }
         let maskContainer = new container_1.Container();
-        if (direction === 'horizontal') {
-            this.createHorizontalMask(size, padding, maskContainer);
+        if (direction === utilities_1.ScrollDirection.Horizontal) {
+            this._createHorizontalMask(size, padding, maskContainer);
         }
         else {
-            this.createVecticalMask(size, padding, maskContainer);
+            this._createVecticalMask(size, padding, maskContainer);
         }
-        this.mask = sprite_1.Sprite.createSnapshotSprite(maskContainer).attach(this);
+        this._maskSprite = sprite_1.Sprite.createSnapshotSprite(maskContainer).attach(this);
         maskContainer.destroy();
-        container.setMask(this.mask);
+        container.setMask(this._maskSprite);
     }
-    createVecticalMask(size, padding, container) {
+    _createVecticalMask(size, padding, container) {
         if (padding > 0) {
-            this.createGradientSprite(new helpers_lib_1.Vector(size.x, padding)).displayParent(container).attach(container);
+            this._createGradientSprite(new helpers_lib_1.Vector(size.x, padding)).displayParent(container).attach(container);
         }
         graphics_1.Graphics.createRectangle(new helpers_lib_1.Vector(size.x, size.y - padding * 2), helpers_lib_1.ColorHelper.white)
             .toSprite()
@@ -68,16 +69,16 @@ class ScrollMaskUI extends container_1.Container {
             .displayParent(container)
             .attach(container);
         if (padding > 0) {
-            this.createGradientSprite(new helpers_lib_1.Vector(size.x, padding))
+            this._createGradientSprite(new helpers_lib_1.Vector(size.x, padding))
                 .setPosition(new helpers_lib_1.Vector(size.x, size.y), { round: false })
                 .setRotation(helpers_lib_1.Radian.get180)
                 .displayParent(container)
                 .attach(container);
         }
     }
-    createHorizontalMask(size, padding, container) {
+    _createHorizontalMask(size, padding, container) {
         if (padding > 0) {
-            this.createGradientSprite(new helpers_lib_1.Vector(size.y, padding))
+            this._createGradientSprite(new helpers_lib_1.Vector(size.y, padding))
                 .setPosition(new helpers_lib_1.Vector(0, size.y), { round: false })
                 .setRotation(helpers_lib_1.Radian.get270)
                 .displayParent(container)
@@ -89,22 +90,22 @@ class ScrollMaskUI extends container_1.Container {
             .displayParent(container)
             .attach(container);
         if (padding > 0) {
-            this.createGradientSprite(new helpers_lib_1.Vector(size.y, padding))
+            this._createGradientSprite(new helpers_lib_1.Vector(size.y, padding))
                 .setPosition(new helpers_lib_1.Vector(size.x, 0), { round: false })
                 .setRotation(helpers_lib_1.Radian.get90)
                 .displayParent(container)
                 .attach(container);
         }
     }
-    createGradientSprite(size) {
-        let textureId = this.createGradientTexture(size.y);
-        let spriteDefinition = { id: textureId, scale: 1, size, anchor: { x: 0, y: 0 }, boundingShapes: undefined };
+    _createGradientSprite(size) {
+        let textureID = this._createGradientTexture(size.y);
+        let spriteDefinition = { id: textureID, scale: 1, size, anchor: { x: 0, y: 0 }, boundingShapes: undefined };
         return new sprite_1.Sprite(spriteDefinition, { textureSize: size, ignoreAnchor: true });
     }
-    createGradientTexture(length) {
+    _createGradientTexture(length) {
         let cacheName = JSON.stringify({ type: 'gradient', length });
-        let textureId = ScrollMaskUI.drawnTextureCache.get(cacheName);
-        if (!textureId) {
+        let textureID = ScrollMaskUI._drawnTextureCache.get(cacheName);
+        if (!textureID) {
             let canvas = document.createElement('canvas');
             canvas.width = 1;
             canvas.height = length;
@@ -116,15 +117,15 @@ class ScrollMaskUI extends container_1.Container {
                     ctx.fillStyle = color;
                     ctx.fillRect(0, index, 1, 1);
                 });
-                let texture = PIXI.Texture.from(canvas);
-                textureId = game_assets_1.GameAssets.insertAsset(texture);
-                ScrollMaskUI.drawnTextureCache.set(cacheName, textureId);
+                let texture = Pixi.Texture.from(canvas);
+                textureID = game_assets_1.GameAssets.insertAsset(texture);
+                ScrollMaskUI._drawnTextureCache.set(cacheName, textureID);
             }
             else {
                 throw new Error('Canvas context is null');
             }
         }
-        return textureId;
+        return textureID;
     }
 }
 exports.ScrollMaskUI = ScrollMaskUI;

package/dist/pixi/display-object/container-attributes.d.ts

@@ -1,30 +1,29 @@
-import { Attachable, IAttachable } from 'actions-lib';
+import { IAttachment, IDAttachable } from 'actions-lib';
 import { Radian, Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
+import * as Pixi from 'pixi.js';
 export declare enum ContainerEventType {
-    click = "click",
-    mouseover = "mouseover",
-    mouseout = "mouseout",
-    pointerdown = "pointerdown",
-    pointerup = "pointerup",
-    pointerupoutside = "pointerupoutside",
-    pointermove = "pointermove",
-    pointercancel = "pointercancel",
-    pointerover = "pointerover",
-    pointerout = "pointerout",
-    pointerenter = "pointerenter",
-    pointerleave = "pointerleave",
-    added = "added",
-    removed = "removed",
-    update = "update",
-    change = "change"
+    Click = "click",
+    MouseOver = "mouseover",
+    MouseOut = "mouseout",
+    PointerDown = "pointerdown",
+    PointerUp = "pointerup",
+    PointerUpOutside = "pointerupoutside",
+    PointerMove = "pointermove",
+    PointerCancel = "pointercancel",
+    PointerOver = "pointerover",
+    PointerOut = "pointerout",
+    PointerEnter = "pointerenter",
+    PointerLeave = "pointerleave",
+    Added = "added",
+    Removed = "removed",
+    Update = "update",
+    Change = "change"
 }
 export declare enum Cursor {
-    default = "default",
-    pointer = "pointer"
+    Default = "default",
+    Pointer = "pointer"
 }
-export declare abstract class ContainerAttributes extends Attachable {
-    protected pixiContainer: PIXI.Container;
+export declare abstract class ContainerAttributes extends IDAttachable {
     protected constructor();
     get size(): Vector;
     set size(value: Vector);
@@ -46,7 +45,7 @@ export declare abstract class ContainerAttributes extends Attachable {
     set x(value: number);
     get y(): number;
     set y(value: number);
-    on(eventType: ContainerEventType, callback: () => void): IAttachable;
+    on(eventType: ContainerEventType, callback: () => void): IAttachment;
     setRotation(value: Radian): this;
     get rotation(): Radian;
     set rotation(value: Radian);
@@ -76,7 +75,7 @@ export declare abstract class ContainerAttributes extends Attachable {
     setCursor(value: Cursor): this;
     get cursor(): Cursor;
     set cursor(value: Cursor);
-    protected getMask(): PIXI.Container;
+    protected getMask(): Pixi.Container;
     private _mask;
     setMask(mask: ContainerAttributes | undefined): this;
     hitTest(stagePosition: Vector): boolean;
@@ -96,5 +95,5 @@ export declare abstract class ContainerAttributes extends Attachable {
     setAspectRatio(value: number): this;
     get aspectRatio(): number;
     set aspectRatio(value: number);
-    private updateScale;
+    private _updateScale;
 }

package/dist/pixi/display-object/container-attributes.js

@@ -26,32 +26,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContainerAttributes = exports.Cursor = exports.ContainerEventType = void 0;
 const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 var ContainerEventType;
 (function (ContainerEventType) {
-    ContainerEventType["click"] = "click";
-    ContainerEventType["mouseover"] = "mouseover";
-    ContainerEventType["mouseout"] = "mouseout";
-    ContainerEventType["pointerdown"] = "pointerdown";
-    ContainerEventType["pointerup"] = "pointerup";
-    ContainerEventType["pointerupoutside"] = "pointerupoutside";
-    ContainerEventType["pointermove"] = "pointermove";
-    ContainerEventType["pointercancel"] = "pointercancel";
-    ContainerEventType["pointerover"] = "pointerover";
-    ContainerEventType["pointerout"] = "pointerout";
-    ContainerEventType["pointerenter"] = "pointerenter";
-    ContainerEventType["pointerleave"] = "pointerleave";
-    ContainerEventType["added"] = "added";
-    ContainerEventType["removed"] = "removed";
-    ContainerEventType["update"] = "update";
-    ContainerEventType["change"] = "change";
+    ContainerEventType["Click"] = "click";
+    ContainerEventType["MouseOver"] = "mouseover";
+    ContainerEventType["MouseOut"] = "mouseout";
+    ContainerEventType["PointerDown"] = "pointerdown";
+    ContainerEventType["PointerUp"] = "pointerup";
+    ContainerEventType["PointerUpOutside"] = "pointerupoutside";
+    ContainerEventType["PointerMove"] = "pointermove";
+    ContainerEventType["PointerCancel"] = "pointercancel";
+    ContainerEventType["PointerOver"] = "pointerover";
+    ContainerEventType["PointerOut"] = "pointerout";
+    ContainerEventType["PointerEnter"] = "pointerenter";
+    ContainerEventType["PointerLeave"] = "pointerleave";
+    ContainerEventType["Added"] = "added";
+    ContainerEventType["Removed"] = "removed";
+    ContainerEventType["Update"] = "update";
+    ContainerEventType["Change"] = "change";
 })(ContainerEventType || (exports.ContainerEventType = ContainerEventType = {}));
 var Cursor;
 (function (Cursor) {
-    Cursor["default"] = "default";
-    Cursor["pointer"] = "pointer";
+    Cursor["Default"] = "default";
+    Cursor["Pointer"] = "pointer";
 })(Cursor || (exports.Cursor = Cursor = {}));
-class ContainerAttributes extends actions_lib_1.Attachable {
+class ContainerAttributes extends actions_lib_1.IDAttachable {
     constructor() {
         super();
         // --------------------- Scale ---------------------
@@ -59,7 +59,7 @@ class ContainerAttributes extends actions_lib_1.Attachable {
         this._flip = false;
         this._scale = 1;
         this._aspectRatio = 1;
-        this.pixiContainer = new PIXI.Container();
+        this.pixiContainer = new Pixi.Container();
     }
     get size() {
         return this.getSize();
@@ -258,7 +258,7 @@ class ContainerAttributes extends actions_lib_1.Attachable {
     }
     set mirror(value) {
         this._mirror = value;
-        this.updateScale();
+        this._updateScale();
     }
     setFlip(flip = false) {
         this.flip = flip;
@@ -269,7 +269,7 @@ class ContainerAttributes extends actions_lib_1.Attachable {
     }
     set flip(value) {
         this._flip = value;
-        this.updateScale();
+        this._updateScale();
     }
     setScale(value) {
         this.scale = value;
@@ -280,7 +280,7 @@ class ContainerAttributes extends actions_lib_1.Attachable {
     }
     set scale(value) {
         this._scale = value;
-        this.updateScale();
+        this._updateScale();
     }
     setAspectRatio(value) {
         this.aspectRatio = value;
@@ -291,9 +291,9 @@ class ContainerAttributes extends actions_lib_1.Attachable {
     }
     set aspectRatio(value) {
         this._aspectRatio = value;
-        this.updateScale();
+        this._updateScale();
     }
-    updateScale() {
+    _updateScale() {
         this.pixiContainer.scale.set(this._scale, this._scale);
         if (this._aspectRatio < 1) {
             this.pixiContainer.scale.x *= this._aspectRatio;

package/dist/pixi/display-object/container.d.ts

@@ -1,13 +1,13 @@
 import { Rectangle } from 'helpers-lib';
 import { ContainerAttributes } from './container-attributes';
 import { Filters } from './filters';
-import { Sprite } from './objects/sprite/sprite';
+import type { Sprite } from './objects/sprite/sprite';
 export interface SetParentOptions {
     addUnder: boolean;
     cropOverflowingParts: boolean;
 }
 export declare class Container extends ContainerAttributes {
-    protected static allContainers: Map<string, Container>;
+    protected static allContainers: Map<number, Container>;
     readonly filters: Filters;
     protected addChildTo: Container;
     protected defaultChildOptions: {
@@ -17,6 +17,6 @@ export declare class Container extends ContainerAttributes {
     constructor();
     destroy(): void;
     getBoundingMask(): Sprite;
-    displayParent(parent: Container | string, partialOptions?: Partial<SetParentOptions>): this;
+    displayParent(parent: Container | number, partialOptions?: Partial<SetParentOptions>): this;
     get boundingBox(): Rectangle;
 }

package/dist/pixi/display-object/container.js

@@ -18,9 +18,9 @@ class Container extends container_attributes_1.ContainerAttributes {
     }
     destroy() {
         if (!this.destroyed) {
+            super.destroy();
             Container.allContainers.delete(this.id);
             !this.pixiContainer.destroyed && this.pixiContainer.destroy();
-            super.destroy();
         }
     }
     getBoundingMask() {
@@ -33,7 +33,7 @@ class Container extends container_attributes_1.ContainerAttributes {
     }
     displayParent(parent, partialOptions) {
         let parentContainer;
-        if (helpers_lib_1.Comparator.isString(parent)) {
+        if (helpers_lib_1.Comparator.isNumber(parent)) {
             parentContainer = Container.allContainers.get(parent);
             if (!parentContainer) {
                 throw new Error(`Container: parent not found! id: ${parent}`);

package/dist/pixi/display-object/filters/base-filters/blur.filter.d.ts

@@ -1,11 +1,11 @@
 import { Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-export declare class BlurFilter extends PIXI.Filter {
-    private strength;
-    private horizontalFilter;
-    private verticalFilter;
-    constructor(strength?: Vector);
-    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode: PIXI.CLEAR_MODES): void;
-    get blendMode(): PIXI.BLEND_MODES;
-    set blendMode(value: PIXI.BLEND_MODES);
+import * as Pixi from 'pixi.js';
+export declare class BlurFilter extends Pixi.Filter {
+    private _strength;
+    private _horizontalFilter;
+    private _verticalFilter;
+    constructor(_strength?: Vector);
+    apply(filterManager: Pixi.FilterSystem, input: Pixi.RenderTexture, output: Pixi.RenderTexture, clearMode: Pixi.CLEAR_MODES): void;
+    get blendMode(): Pixi.BLEND_MODES;
+    set blendMode(value: Pixi.BLEND_MODES);
 }