bard-legends-framework 0.10.8 → 0.10.9

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

@@ -1,11 +1,18 @@
 import { Action } from 'actions-lib';
-export declare abstract class Attachable {
+export declare class Attachable {
+    readonly id: string;
     private attachedParent;
+    private attachments;
     private _attachIsCalled;
     private _destroyed;
     get destroyed(): boolean;
     readonly onDestroy: Action<void>;
     constructor();
-    protected afterDestroy(): void;
-    protected destroySelf(): void;
+    destroy(): void;
+    attach(parent: Attachable | string): this;
+    attachToRoot(): this;
+    private setAttachment;
+    private removeAttachment;
+    private checkCircularAttachment;
+    private destroyAttachment;
 }

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

@@ -2,12 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Attachable = void 0;
 const actions_lib_1 = require("actions-lib");
-const attachment_target_store_1 = require("./helpers/attachment-target.store");
+const helpers_lib_1 = require("helpers-lib");
+const attachable_store_1 = require("./helpers/attachable.store");
 class Attachable {
     get destroyed() {
         return this._destroyed;
     }
     constructor() {
+        this.id = attachable_store_1.AttachableStore.registerAttachmentTarget(this);
+        this.attachments = [];
         this._attachIsCalled = false;
         this._destroyed = false;
         this.onDestroy = new actions_lib_1.Action();
@@ -17,39 +20,32 @@ class Attachable {
             }
         });
     }
-    /** @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.attachedParent?.removeAttachment(this);
+            this.attachedParent = undefined;
+            attachable_store_1.AttachableStore.unregisterAttachmentTarget(this);
+            let onDestroyListeners = [...this.onDestroy['notificationHandler']['listenersMap'].values()];
+            let attachedEntities = [...this.attachments];
+            attachedEntities.forEach(item => this.destroyAttachment(item));
+            this.attachments = [];
             this._destroyed = true;
+            onDestroyListeners.forEach(listener => listener());
         }
     }
-    afterDestroy() { }
-    destroySelf() {
-        this.onDestroy.trigger();
-        this.attachedParent?.removeAttachment(this);
-        this.attachedParent = undefined;
-    }
-    /** @internal */
     attach(parent) {
         if (this._attachIsCalled) {
             throw new Error(`Attachable: The object is already attached to something!`);
         }
         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}"`);
-            }
+            let parentEntity = attachable_store_1.AttachableStore.findAttachmentTarget(parent);
+            this.checkCircularAttachment(parentEntity);
             this.attachedParent = parentEntity;
             parentEntity.setAttachment(this);
         }
         return this;
     }
-    /** @internal */
     attachToRoot() {
         if (this._attachIsCalled) {
             throw new Error(`Attachable: The object is already attached to something!`);
@@ -57,6 +53,42 @@ class Attachable {
         this._attachIsCalled = true;
         return this;
     }
+    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);
+        }
+    }
+    checkCircularAttachment(parentEntity) {
+        while (parentEntity) {
+            if (parentEntity === this) {
+                throw new Error(`Circular attachment detected!`);
+            }
+            parentEntity = parentEntity.attachedParent;
+        }
+    }
+    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.Attachable = Attachable;
 //# sourceMappingURL=attachable.js.map

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

@@ -15,12 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 = {};
@@ -28,112 +22,104 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 attachable_store_1 = require("./helpers/attachable.store");
 const decorate_actions_lib_1 = require("./helpers/decorate-actions-lib");
 decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
-(0, vitest_1.describe)('ATTACHABLE', () => {
+(0, vitest_1.describe)('Attachable', () => {
     (0, vitest_1.beforeEach)(() => {
-        update_cycle_1.UpdateCycle.hardResetAction.trigger();
-        let SampleScene = class SampleScene extends scene_1.Scene {
-        };
-        SampleScene = __decorate([
-            (0, scene_1.SceneDecorator)()
-        ], SampleScene);
-        SampleScene.open(undefined);
+        attachable_store_1.AttachableStore.hardReset();
     });
-    (0, vitest_1.test)('dummy', () => {
-        (0, vitest_1.expect)(true).toBeTruthy();
+    (0, vitest_1.test)('attach to self should throw error', () => {
+        class Sample extends attachable_1.Attachable {
+        }
+        let sample = new Sample();
+        (0, vitest_1.expect)(() => {
+            sample.attach(sample);
+        }).toThrow('Circular attachment detected!');
     });
-    (0, vitest_1.test)('destroyable', async () => {
-        let Sample = class Sample extends entity_1.Entity {
-        };
-        Sample = __decorate([
-            (0, entity_1.EntityDecorator)()
-        ], Sample);
-        class Foo {
-            constructor() {
-                this.destroyed = false;
-            }
-            destroy() {
-                this.destroyed = true;
-            }
+    (0, vitest_1.test)('circular attachment should throw error', () => {
+        class Sample 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();
+        let sample1 = new Sample();
+        let sample2 = new Sample();
+        (0, vitest_1.expect)(() => {
+            sample2.attach(sample1);
+            sample1.attach(sample2);
+        }).toThrow('Circular attachment detected!');
+    });
+    (0, vitest_1.test)('when attachment target is destroyed, it should destroy its attachments', () => {
+        class Target extends attachable_1.Attachable {
+        }
+        class Attachment extends attachable_1.Attachable {
+        }
+        let target = new Target();
+        let attachment = new Attachment().attach(target);
+        target.destroy();
+        (0, vitest_1.expect)(attachment.destroyed).toBeTruthy();
     });
-    (0, vitest_1.test)('destroyable, delayed', async () => {
-        let Sample = class Sample extends entity_1.Entity {
-        };
-        Sample = __decorate([
-            (0, entity_1.EntityDecorator)()
-        ], Sample);
-        class Foo {
+    (0, vitest_1.test)('attached on constructor', () => {
+        let child;
+        class Target extends attachable_1.Attachable {
             constructor() {
-                this.destroyed = false;
-            }
-            destroy() {
-                this.destroyed = true;
+                super();
+                child = new Attachment().attach(this);
             }
         }
-        let sample = new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
-        let foo = new Foo();
-        sample['setAttachment'](foo);
+        class Attachment extends attachable_1.Attachable {
+        }
+        let parent = new Target().attachToRoot();
+        parent.destroy();
+        (0, vitest_1.expect)(child?.destroyed).toBeTruthy();
+    });
+    (0, vitest_1.test)('onDestroy should be triggered when destroy is called', () => {
+        class Sample extends attachable_1.Attachable {
+        }
+        let parent = new Sample().attachToRoot();
+        let sample = new Sample().attachToRoot();
+        let destroyCalled = false;
+        sample.onDestroy
+            .subscribe(() => {
+            destroyCalled = true;
+        })
+            .attach(parent);
         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.expect)(destroyCalled).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);
+    (0, vitest_1.test)('onDestroy should be triggered when destroy listener is attached to itself', () => {
+        class Sample extends attachable_1.Attachable {
+        }
+        let sample = new Sample().attachToRoot();
+        let destroyCalled = false;
+        sample.onDestroy
+            .subscribe(() => {
+            destroyCalled = true;
+        })
+            .attach(sample);
         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.expect)(destroyCalled).toBeTruthy();
     });
-    (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();
+    (0, vitest_1.test)('onDestroy calls should be executed attached first then parent', () => {
+        class Sample extends attachable_1.Attachable {
+        }
+        let sample1 = new Sample().attachToRoot();
+        let sample2 = new Sample().attach(sample1);
+        let heap = [];
+        sample1.onDestroy
+            .subscribe(() => {
+            heap.push('sample1');
+        })
+            .attach(sample1);
+        sample2.onDestroy
+            .subscribe(() => {
+            heap.push('sample2');
+        })
+            .attach(sample2);
+        sample1.destroy();
+        (0, vitest_1.expect)(heap).toEqual(['sample2', 'sample1']);
     });
 });
 //# sourceMappingURL=attachable.test.js.map

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

@@ -1,8 +1,2 @@
-import { IAttachmentTarget } from '../interfaces';
-export declare class AttachableStore {
-    private static nextAvailableIds;
-    private static attachables;
-    static findAttachableParent(attachableCandidate: IAttachmentTarget | string): IAttachmentTarget;
-    static registerAttachable(attachable: IAttachmentTarget): string;
-    static unregisterAttachable(attachable: IAttachmentTarget): void;
-}
+import { Attachable } from '../attachable';
+export type AttachableConstructor = new (...args: any[]) => Attachable;

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

@@ -3,37 +3,66 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AttachableStore = void 0;
 const helpers_lib_1 = require("helpers-lib");
 const update_cycle_1 = require("../../update-cycle");
+/** @internal */
 class AttachableStore {
-    static { this.nextAvailableIds = new Map(); }
-    static { this.attachables = new Map(); }
-    static findAttachableParent(attachableCandidate) {
-        let attachable;
+    static { this.nextClassId = 1; }
+    static { this.classToClassId = new WeakMap(); }
+    static { this.nextAvailableIds = new WeakMap(); }
+    static { this.idToAttachmentTarget = new Map(); }
+    static { this.idToAttachmentTargetClass = new Map(); }
+    static findAttachmentTarget(attachableCandidate) {
+        let attachmentTarget;
         if (helpers_lib_1.Comparator.isString(attachableCandidate)) {
             let attachableId = attachableCandidate;
-            attachable = this.attachables.get(attachableId);
-            if (!attachable) {
+            attachmentTarget = this.idToAttachmentTarget.get(attachableId);
+            if (!attachmentTarget) {
                 throw new Error(`Attachable: attachable not found by id! id: ${attachableId}`);
             }
         }
         else {
-            attachable = attachableCandidate;
+            attachmentTarget = attachableCandidate;
         }
-        return attachable;
+        return attachmentTarget;
     }
-    static registerAttachable(attachable) {
-        let numberPartOfTheId = AttachableStore.nextAvailableIds.get(attachable.constructor.name) || 1;
-        AttachableStore.nextAvailableIds.set(attachable.constructor.name, numberPartOfTheId + 1);
-        let id = `${attachable.constructor.name}:${numberPartOfTheId}`;
-        AttachableStore.attachables.set(id, attachable);
+    static registerAttachmentTarget(attachmentTarget) {
+        let Class = attachmentTarget.constructor;
+        let numberPartOfTheId = this.nextAvailableIds.get(Class) || 1;
+        this.nextAvailableIds.set(Class, numberPartOfTheId + 1);
+        let classId = this.getClassId(Class);
+        let id = `${classId}:${numberPartOfTheId}`;
+        this.idToAttachmentTarget.set(id, attachmentTarget);
+        this.idToAttachmentTargetClass.set(id, Class);
         return id;
     }
-    static unregisterAttachable(attachable) {
-        AttachableStore.attachables.delete(attachable.id);
+    static unregisterAttachmentTarget(attachmentTarget) {
+        this.idToAttachmentTarget.delete(attachmentTarget.id);
+        this.idToAttachmentTargetClass.delete(attachmentTarget.id);
+    }
+    static validateIdForClass(id, expectedConstructor) {
+        let actualConstructor = this.idToAttachmentTargetClass.get(id);
+        return actualConstructor === expectedConstructor;
+    }
+    /**
+     * Required to be called before or after each unit test to reset the store
+     */
+    static hardReset() {
+        this.nextClassId = 1;
+        this.classToClassId = new WeakMap();
+        this.nextAvailableIds = new WeakMap();
+        this.idToAttachmentTarget.clear();
+        this.idToAttachmentTargetClass.clear();
+    }
+    static getClassId(Class) {
+        let id = this.classToClassId.get(Class);
+        if (!id) {
+            id = `${this.nextClassId++}`;
+            this.classToClassId.set(Class, id);
+        }
+        return id;
     }
 }
 exports.AttachableStore = AttachableStore;
 update_cycle_1.UpdateCycle.hardResetAction.subscribe(() => {
-    AttachableStore['nextAvailableIds'].clear();
-    AttachableStore['attachables'].clear();
+    AttachableStore.hardReset();
 });
 //# sourceMappingURL=attachable.store.js.map

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

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