bard-legends-framework 0.10.5 → 0.10.6

package/dist/game-entities/_base/attachable.d.ts

@@ -0,0 +1,10 @@
+import { IAttachmentTarget } from './attachment-target';
+import { Destroyable } from './destroyable';
+export declare class AttachableBehavior extends Destroyable {
+    private _attachIsCalled;
+    private _attachedTarget;
+    constructor();
+    destroy(): void;
+    attach(parent: IAttachmentTarget | string): this;
+    attachToRoot(): this;
+}

package/dist/game-entities/_base/attachable.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachableBehavior = void 0;
+const attachable_store_1 = require("./attachable.store");
+const destroyable_1 = require("./destroyable");
+class AttachableBehavior extends destroyable_1.Destroyable {
+    constructor() {
+        super();
+        this._attachIsCalled = false;
+        setTimeout(() => {
+            if (!this.destroyed && !this._attachIsCalled) {
+                throw new Error(`AttachableBehavior: The object is not attached to anything!`);
+            }
+        });
+    }
+    destroy() {
+        if (!this.destroyed) {
+            this._attachedTarget?.attachmentTargetBehavior.removeAttachment(this);
+            this._attachedTarget = undefined;
+            super.destroy();
+        }
+    }
+    attach(parent) {
+        if (this._attachIsCalled) {
+            throw new Error(`AttachableBehavior: The object is already attached to something!`);
+        }
+        this._attachIsCalled = true;
+        if (!this.destroyed) {
+            let target = attachable_store_1.AttachableStore.findAttachmentTarget(parent);
+            if (target === this) {
+                throw new Error(`Objects cannot be attach to itself! entity: "${this.constructor.name}"`);
+            }
+            this._attachedTarget = target;
+            target.attachmentTargetBehavior.setAttachment(this);
+        }
+        return this;
+    }
+    attachToRoot() {
+        if (this._attachIsCalled) {
+            throw new Error(`AttachableBehavior: The object is already attached to something!`);
+        }
+        this._attachIsCalled = true;
+        return this;
+    }
+}
+exports.AttachableBehavior = AttachableBehavior;
+//# sourceMappingURL=attachable.js.map

package/dist/game-entities/_base/attachable.store.d.ts

@@ -0,0 +1,8 @@
+import { IAttachmentTarget } from './attachment-target';
+export declare class AttachableStore {
+    private static nextAvailableIds;
+    private static attachmentTargets;
+    static registerAttachmentTarget(target: IAttachmentTarget): string;
+    static unregisterAttachmentTarget(target: IAttachmentTarget): void;
+    static findAttachmentTarget(targetCandidate: IAttachmentTarget | string): IAttachmentTarget;
+}

package/dist/game-entities/_base/attachable.store.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachableStore = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const update_cycle_1 = require("../update-cycle");
+class AttachableStore {
+    static { this.nextAvailableIds = new Map(); }
+    static { this.attachmentTargets = new Map(); }
+    static registerAttachmentTarget(target) {
+        let numberPartOfTheId = AttachableStore.nextAvailableIds.get(target.constructor.name) || 1;
+        AttachableStore.nextAvailableIds.set(target.constructor.name, numberPartOfTheId + 1);
+        let id = `${target.constructor.name}:${numberPartOfTheId}`;
+        AttachableStore.attachmentTargets.set(id, target);
+        return id;
+    }
+    static unregisterAttachmentTarget(target) {
+        AttachableStore.attachmentTargets.delete(target.attachmentTargetBehavior.id);
+    }
+    static findAttachmentTarget(targetCandidate) {
+        let target;
+        if (helpers_lib_1.Comparator.isString(targetCandidate)) {
+            if (!this.attachmentTargets.has(targetCandidate)) {
+                throw new Error(`Attachable: attachable not found by id! id: ${targetCandidate}`);
+            }
+            else {
+                target = this.attachmentTargets.get(targetCandidate);
+            }
+        }
+        else if (targetCandidate.attachmentTargetBehavior) {
+            target = targetCandidate;
+        }
+        else {
+            throw new Error(`Attachable: attachable is not an AttachableBehavior! Attachable: "${targetCandidate}"`);
+        }
+        return target;
+    }
+}
+exports.AttachableStore = AttachableStore;
+update_cycle_1.UpdateCycle.hardResetAction.subscribe(() => {
+    AttachableStore['nextAvailableIds'].clear();
+    AttachableStore['attachmentTargets'].clear();
+});
+//# sourceMappingURL=attachable.store.js.map

package/dist/game-entities/_base/attachment-target.d.ts

@@ -0,0 +1,16 @@
+import { Destroyable } from './destroyable';
+import { Attachable } from './interfaces';
+export interface IAttachmentTarget {
+    readonly attachmentTargetBehavior: AttachmentTargetBehavior;
+}
+export declare class AttachmentTargetBehavior {
+    private base;
+    private _destroyed;
+    private _attachments;
+    readonly id: string;
+    constructor(base: Destroyable & IAttachmentTarget);
+    destroy(): void;
+    setAttachment(child: Attachable): void;
+    removeAttachment(child: Attachable): void;
+    private destroyAttachment;
+}

package/dist/game-entities/_base/attachment-target.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentTargetBehavior = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const attachable_store_1 = require("./attachable.store");
+class AttachmentTargetBehavior {
+    constructor(base) {
+        this.base = base;
+        this._destroyed = false;
+        this._attachments = [];
+        this.id = '';
+        this.id = attachable_store_1.AttachableStore.registerAttachmentTarget(this.base);
+    }
+    destroy() {
+        if (!this._destroyed) {
+            attachable_store_1.AttachableStore.unregisterAttachmentTarget(this.base);
+            let attachedEntities = [...this._attachments];
+            attachedEntities.forEach(item => this.destroyAttachment(item));
+            this._attachments = [];
+            this._destroyed = true;
+        }
+    }
+    setAttachment(child) {
+        if (this._destroyed) {
+            this.destroyAttachment(child);
+        }
+        else {
+            this._attachments.push(child);
+        }
+    }
+    removeAttachment(child) {
+        let index = this._attachments.indexOf(child);
+        if (index >= 0) {
+            this._attachments.splice(index, 1);
+        }
+    }
+    destroyAttachment(object) {
+        if (helpers_lib_1.Comparator.isObject(object)) {
+            let item = object;
+            if (helpers_lib_1.Comparator.isFunction(item.destroy)) {
+                item.destroy();
+                return;
+            }
+            else if (helpers_lib_1.Comparator.isFunction(item.unsubscribe)) {
+                item.unsubscribe();
+                return;
+            }
+        }
+        throw new Error(`Destroyable: destroyAttachment is used with not supperted type! Target: "${object}"`);
+    }
+}
+exports.AttachmentTargetBehavior = AttachmentTargetBehavior;
+//# sourceMappingURL=attachment-target.js.map

package/dist/game-entities/_base/destroyable.d.ts

@@ -0,0 +1,3 @@
+export declare class DestroyableBehavior {
+    destroy(): void;
+}

package/dist/game-entities/_base/destroyable.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DestroyableBehavior = void 0;
+class DestroyableBehavior {
+    destroy() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.DestroyableBehavior = DestroyableBehavior;
+//# sourceMappingURL=destroyable.js.map

package/dist/game-entities/_base/interfaces.d.ts

@@ -0,0 +1,3 @@
+export interface IDestroyable {
+    destroy(): void;
+}

package/dist/game-entities/_base/interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interfaces.js.map

package/dist/game-entities/_base/mixins.d.ts

@@ -0,0 +1,22 @@
+export declare abstract class Destroyable {
+    private _destroyed;
+    destroy(): void;
+}
+export declare abstract class Attachable {
+    private _attached;
+    attach(): void;
+}
+type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;
+export declare function AttachmentTarget<BaseType extends AbstractConstructor>(Base: BaseType): (abstract new (...args: any[]) => {
+    readonly id: string;
+    destroy(): void;
+}) & BaseType;
+export declare function WithDestroyableTarget<BaseType extends AbstractConstructor<Destroyable>>(Base: BaseType): BaseType;
+declare const Foo_base: (abstract new (...args: any[]) => {
+    readonly id: string;
+    destroy(): void;
+}) & typeof Destroyable;
+export declare class Foo extends Foo_base {
+    constructor();
+}
+export {};

package/dist/game-entities/_base/mixins.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Foo = exports.WithDestroyableTarget = exports.AttachmentTarget = exports.Attachable = exports.Destroyable = void 0;
+class Destroyable {
+    constructor() {
+        this._destroyed = false;
+    }
+    destroy() {
+        if (!this._destroyed) {
+            this._destroyed = true;
+        }
+        console.log('Destroyable destroy');
+    }
+}
+exports.Destroyable = Destroyable;
+class Attachable {
+    constructor() {
+        this._attached = false;
+    }
+    attach() {
+        if (!this._attached) {
+            this._attached = true;
+        }
+    }
+}
+exports.Attachable = Attachable;
+function AttachmentTarget(Base) {
+    class AttachmentTarget extends Base {
+        constructor() {
+            super(...arguments);
+            this.id = '';
+        }
+        destroy() {
+            // some destroy logic
+            console.log('AttachmentTarget destroy');
+        }
+    }
+    return AttachmentTarget;
+}
+exports.AttachmentTarget = AttachmentTarget;
+function WithDestroyableTarget(Base) {
+    class WithDestroyableTarget extends Base {
+        destroy() {
+            // I don't want to repeat the "some destroy logic" here
+            super.destroy();
+            console.log('WithDestroyableTarget destroy');
+        }
+    }
+    return WithDestroyableTarget;
+}
+exports.WithDestroyableTarget = WithDestroyableTarget;
+class Foo extends WithDestroyableTarget(AttachmentTarget(Destroyable)) {
+    constructor() {
+        super();
+    }
+}
+exports.Foo = Foo;
+let foo = new Foo();
+foo.destroy();
+//# sourceMappingURL=mixins.js.map

package/dist/game-entities/base/attachable.d.ts

@@ -1,10 +1,11 @@
-import { Destroyable } from './destroyable';
-import { CanBeAttached, IAttachable } from './interfaces';
-export declare abstract class Attachable extends Destroyable implements IAttachable {
-    readonly id: string;
-    private attachments;
+import { Action } from 'actions-lib';
+export declare abstract class Attachable {
+    private attachedParent;
+    private _attachIsCalled;
+    private _destroyed;
+    get destroyed(): boolean;
+    readonly onDestroy: Action<void>;
     constructor();
+    protected afterDestroy(): void;
     protected destroySelf(): void;
-    setAttachment(child: CanBeAttached): void;
-    removeAttachment(child: CanBeAttached): void;
 }

package/dist/game-entities/base/attachable.js

@@ -1,35 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Attachable = void 0;
-const destroyable_1 = require("./destroyable");
-const attachable_store_1 = require("./helpers/attachable.store");
-class Attachable extends destroyable_1.Destroyable {
+const actions_lib_1 = require("actions-lib");
+const attachment_target_store_1 = require("./helpers/attachment-target.store");
+class Attachable {
+    get destroyed() {
+        return this._destroyed;
+    }
     constructor() {
-        super();
-        this.id = '';
-        this.attachments = [];
-        this.id = attachable_store_1.AttachableStore.registerAttachable(this);
+        this._attachIsCalled = false;
+        this._destroyed = false;
+        this.onDestroy = new actions_lib_1.Action();
+        setTimeout(() => {
+            if (!this._destroyed && !this._attachIsCalled) {
+                throw new Error(`Attachable: The object is not attached to anything!`);
+            }
+        });
+    }
+    /** @internal */
+    destroy() {
+        if (!this._destroyed) {
+            // Destroy self is needed to ensure the "afterDestroy" is called after all child destroy functions are called
+            this.destroySelf();
+            this.afterDestroy();
+            this._destroyed = true;
+        }
     }
+    afterDestroy() { }
     destroySelf() {
-        super.destroySelf();
-        attachable_store_1.AttachableStore.unregisterAttachable(this);
-        let attachedEntities = [...this.attachments];
-        attachedEntities.forEach(item => this.destroyAttachment(item));
-        this.attachments = [];
+        this.onDestroy.trigger();
+        this.attachedParent?.removeAttachment(this);
+        this.attachedParent = undefined;
     }
-    setAttachment(child) {
-        if (this.destroyed) {
-            this.destroyAttachment(child);
+    /** @internal */
+    attach(parent) {
+        if (this._attachIsCalled) {
+            throw new Error(`Attachable: The object is already attached to something!`);
         }
-        else {
-            this.attachments.push(child);
+        this._attachIsCalled = true;
+        if (!this._destroyed) {
+            let parentEntity = attachment_target_store_1.AttachmentTargetStore.findAttachableParent(parent);
+            // @ts-ignore
+            if (parentEntity === this) {
+                throw new Error(`Entity cannot be attach to itself! entity: "${this.constructor.name}"`);
+            }
+            this.attachedParent = parentEntity;
+            parentEntity.setAttachment(this);
         }
+        return this;
     }
-    removeAttachment(child) {
-        let index = this.attachments.indexOf(child);
-        if (index >= 0) {
-            this.attachments.splice(index, 1);
+    /** @internal */
+    attachToRoot() {
+        if (this._attachIsCalled) {
+            throw new Error(`Attachable: The object is already attached to something!`);
         }
+        this._attachIsCalled = true;
+        return this;
     }
 }
 exports.Attachable = Attachable;

package/dist/game-entities/base/attachment-target.d.ts

@@ -0,0 +1,9 @@
+import { Attachable } from './attachable';
+import { IAttachmentTarget } from './interfaces';
+export declare abstract class AttachmentTarget extends Attachable implements IAttachmentTarget {
+    readonly id: string;
+    private attachments;
+    constructor();
+    protected destroySelf(): void;
+    private destroyAttachment;
+}

package/dist/game-entities/base/attachment-target.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentTarget = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const attachable_1 = require("./attachable");
+const attachment_target_store_1 = require("./helpers/attachment-target.store");
+class AttachmentTarget extends attachable_1.Attachable {
+    constructor() {
+        super();
+        this.id = '';
+        this.attachments = [];
+        this.id = attachment_target_store_1.AttachmentTargetStore.registerAttachable(this);
+    }
+    destroySelf() {
+        super.destroySelf();
+        attachment_target_store_1.AttachmentTargetStore.unregisterAttachable(this);
+        let attachedEntities = [...this.attachments];
+        attachedEntities.forEach(item => this.destroyAttachment(item));
+        this.attachments = [];
+    }
+    /** @internal */
+    setAttachment(child) {
+        if (this.destroyed) {
+            this.destroyAttachment(child);
+        }
+        else {
+            this.attachments.push(child);
+        }
+    }
+    /** @internal */
+    removeAttachment(child) {
+        let index = this.attachments.indexOf(child);
+        if (index >= 0) {
+            this.attachments.splice(index, 1);
+        }
+    }
+    destroyAttachment(object) {
+        if (helpers_lib_1.Comparator.isObject(object)) {
+            let item = object;
+            if (helpers_lib_1.Comparator.isFunction(item.destroy)) {
+                item.destroy();
+                return;
+            }
+            else if (helpers_lib_1.Comparator.isFunction(item.unsubscribe)) {
+                item.unsubscribe();
+                return;
+            }
+        }
+        throw new Error(`AttachmentTarget: destroyAttachment is used with not supperted type! Target: "${object}"`);
+    }
+}
+exports.AttachmentTarget = AttachmentTarget;
+//# sourceMappingURL=attachment-target.js.map

package/dist/game-entities/base/attachment-target.test.d.ts

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

package/dist/game-entities/base/attachment-target.test.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ActionsLib = __importStar(require("actions-lib"));
+const actions_lib_1 = require("actions-lib");
+const vitest_1 = require("vitest");
+const entity_1 = require("../entity/entity");
+const scene_1 = require("../scene/scene");
+const update_cycle_1 = require("../update-cycle");
+const attachable_1 = require("./attachable");
+const decorate_actions_lib_1 = require("./helpers/decorate-actions-lib");
+decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
+(0, vitest_1.describe)('ATTACHMENT_TARGET', () => {
+    (0, vitest_1.beforeEach)(() => {
+        update_cycle_1.UpdateCycle.hardResetAction.trigger();
+        let SampleScene = class SampleScene extends scene_1.Scene {
+            async init() { }
+            update() { }
+            async prepareToClose() { }
+        };
+        SampleScene = __decorate([
+            (0, scene_1.SceneDecorator)()
+        ], SampleScene);
+        SampleScene.open();
+    });
+    (0, vitest_1.test)('dummy', () => {
+        (0, vitest_1.expect)(true).toBeTruthy();
+    });
+    (0, vitest_1.test)('attachable', async () => {
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        class Foo extends attachable_1.Attachable {
+        }
+        let sample = new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
+        let foo = new Foo();
+        sample.setAttachment(foo);
+        sample.destroy();
+        await update_cycle_1.UpdateCycle.triggerUpdateTick(1); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(foo.destroyed).toBeTruthy();
+    });
+    (0, vitest_1.test)('attachable, delayed', async () => {
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        class Foo extends attachable_1.Attachable {
+        }
+        let sample = new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
+        let foo = new Foo();
+        sample.setAttachment(foo);
+        sample.destroy();
+        await update_cycle_1.UpdateCycle.triggerUpdateTick(1); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(foo.destroyed).toBeTruthy();
+    });
+    (0, vitest_1.test)('subscription', async () => {
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let foo = new actions_lib_1.Variable();
+        let sample = new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
+        (0, vitest_1.expect)(foo.listenerCount).toEqual(0);
+        foo.subscribe(() => { }).attach(sample);
+        (0, vitest_1.expect)(foo.listenerCount).toEqual(1);
+        sample.destroy();
+        await update_cycle_1.UpdateCycle.triggerUpdateTick(1); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(foo.listenerCount).toEqual(0);
+    });
+    (0, vitest_1.test)('entity attachment in constructor', async () => {
+        let childDestoyIsCalled = false;
+        let Parent = class Parent extends entity_1.Entity {
+            constructor() {
+                super();
+                new Child().attach(this);
+            }
+        };
+        Parent = __decorate([
+            (0, entity_1.EntityDecorator)(),
+            __metadata("design:paramtypes", [])
+        ], Parent);
+        let Child = class Child extends entity_1.Entity {
+            afterDestroy() {
+                childDestoyIsCalled = true;
+            }
+        };
+        Child = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Child);
+        let parent = new Parent().attach(scene_1.Scene.getActiveSceneOrFail());
+        parent.destroy();
+        await update_cycle_1.UpdateCycle.triggerUpdateTick(1); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(childDestoyIsCalled).toBeTruthy();
+    });
+});
+//# sourceMappingURL=attachment-target.test.js.map

package/dist/game-entities/base/destroyable.d.ts

@@ -1,5 +1,5 @@
 import { Action } from 'actions-lib';
-import { CanBeAttached, IAttachable } from './interfaces';
+import { IAttachmentTarget } from './interfaces';
 export declare abstract class Destroyable {
     private attachedParent;
     private _attachIsCalled;
@@ -11,7 +11,6 @@ export declare abstract class Destroyable {
     destroy(): void;
     protected afterDestroy(): void;
     protected destroySelf(): void;
-    attach(parent: IAttachable | string): this;
+    attach(parent: IAttachmentTarget | string): this;
     attachToRoot(): this;
-    protected destroyAttachment(object: CanBeAttached): void;
 }

package/dist/game-entities/base/destroyable.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Destroyable = void 0;
 const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
 const attachable_store_1 = require("./helpers/attachable.store");
 class Destroyable {
     get attachIsCalled() {
@@ -57,26 +56,6 @@ class Destroyable {
         this._attachIsCalled = true;
         return this;
     }
-    destroyAttachment(object) {
-        if (object instanceof actions_lib_1.Variable) {
-            this.destroyAttachment(object.value);
-        }
-        else if (object instanceof Array) {
-            object.forEach((item) => this.destroyAttachment(item));
-        }
-        else if (helpers_lib_1.Comparator.isObject(object)) {
-            let item = object;
-            if (helpers_lib_1.Comparator.isFunction(item.destroy)) {
-                item.destroy();
-            }
-            else if (helpers_lib_1.Comparator.isFunction(item.unsubscribe)) {
-                item.unsubscribe();
-            }
-        }
-        else {
-            throw new Error(`Destroyable: destroyAttachment is used with not supperted type! Target: "${object}"`);
-        }
-    }
 }
 exports.Destroyable = Destroyable;
 //# sourceMappingURL=destroyable.js.map

package/dist/game-entities/base/helpers/attachable.store.d.ts

@@ -1,8 +1,8 @@
-import { IAttachable } from '../interfaces';
+import { IAttachmentTarget } from '../interfaces';
 export declare class AttachableStore {
     private static nextAvailableIds;
     private static attachables;
-    static findAttachableParent(attachableCandidate: IAttachable | string): IAttachable;
-    static registerAttachable(attachable: IAttachable): string;
-    static unregisterAttachable(attachable: IAttachable): void;
+    static findAttachableParent(attachableCandidate: IAttachmentTarget | string): IAttachmentTarget;
+    static registerAttachable(attachable: IAttachmentTarget): string;
+    static unregisterAttachable(attachable: IAttachmentTarget): void;
 }

package/dist/game-entities/base/helpers/attachment-target.store.d.ts

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