bard-legends-framework 0.9.4 → 0.9.6

package/dist/game-entities/view/view.spec.js

@@ -0,0 +1,514 @@
+"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 vitest_1 = require("vitest");
+const helpers_lib_1 = require("helpers-lib");
+const actions_lib_1 = require("actions-lib");
+const ActionsLib = __importStar(require("actions-lib"));
+const entity_1 = require("../entity/entity");
+const view_1 = require("./view");
+const update_loop_1 = require("../update-loop");
+const scene_1 = require("../scene/scene");
+const decorate_actions_lib_1 = require("../attachable/helpers/decorate-actions-lib");
+decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
+(0, vitest_1.describe)('VIEW', () => {
+    (0, vitest_1.beforeEach)(() => {
+        update_loop_1.UpdateCycle.hardResetAction.trigger();
+        let SampleScene = class SampleScene extends scene_1.Scene {
+        };
+        SampleScene = __decorate([
+            (0, scene_1.SceneDecorator)()
+        ], SampleScene);
+        SampleScene.open(undefined);
+    });
+    (0, vitest_1.test)('entity creation should create related view', () => {
+        var SampleView_1;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_1 = this; }
+            constructor(entity) {
+                super();
+                SampleView_1.viewInstance = this;
+            }
+        };
+        SampleView = SampleView_1 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        new Sample().attach(scene_1.Scene.activeScene);
+        (0, vitest_1.expect)(SampleView.viewInstance).toBeDefined();
+    });
+    (0, vitest_1.test)('class names should be unique', () => {
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        (0, vitest_1.expect)(() => {
+            {
+                let SampleView = class SampleView extends view_1.View {
+                };
+                SampleView = __decorate([
+                    (0, view_1.ViewDecorator)({ entity: Sample })
+                ], SampleView);
+            }
+            {
+                let SampleView = class SampleView extends view_1.View {
+                };
+                SampleView = __decorate([
+                    (0, view_1.ViewDecorator)({ entity: Sample })
+                ], SampleView);
+            }
+        }).toThrow();
+    });
+    (0, vitest_1.test)('entity creation should create related view once', () => {
+        var SampleView_2;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_2 = this; }
+            static { this.viewCall = 0; }
+            constructor(entity) {
+                super();
+                SampleView_2.viewCall++;
+            }
+        };
+        SampleView = SampleView_2 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        new Sample().attach(scene_1.Scene.activeScene);
+        (0, vitest_1.expect)(SampleView.viewCall).toEqual(1);
+    });
+    (0, vitest_1.test)('entities should not destroy each others views on destroy', () => {
+        var SampleView_3;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let baseEntity = new BaseEntity().attach(scene_1.Scene.activeScene);
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_3 = this; }
+            static { this.viewInstanceCount = 0; }
+            constructor(entity) {
+                super();
+                SampleView_3.viewInstanceCount++;
+            }
+            destroy() {
+                SampleView_3.viewInstanceCount--;
+            }
+        };
+        SampleView = SampleView_3 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        let entity1 = new Sample().attach(baseEntity);
+        let entity2 = new Sample().attach(baseEntity);
+        (0, vitest_1.expect)(SampleView.viewInstanceCount).toEqual(2);
+        entity1.destroy();
+        update_loop_1.UpdateCycle.triggerUpdateTick(0); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(SampleView.viewInstanceCount).toEqual(1);
+        entity2.destroy();
+        update_loop_1.UpdateCycle.triggerUpdateTick(0); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(SampleView.viewInstanceCount).toEqual(0);
+    });
+    (0, vitest_1.test)('entity destruction should destroy related views', () => {
+        let viewDestroyCount = 0;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            destroy() {
+                viewDestroyCount++;
+            }
+        };
+        SampleView = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample })
+        ], SampleView);
+        let entity = new Sample().attach(scene_1.Scene.activeScene);
+        entity.destroy();
+        update_loop_1.UpdateCycle.triggerUpdateTick(0); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(viewDestroyCount).toEqual(1);
+    });
+    (0, vitest_1.test)('view destruction should destroy attached items', () => {
+        let viewDestroyCount = 0;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let Sample2 = class Sample2 extends entity_1.Entity {
+            destroy() {
+                viewDestroyCount++;
+            }
+        };
+        Sample2 = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample2);
+        let SampleView = class SampleView extends view_1.View {
+            constructor(entity) {
+                super();
+                new Sample2().attach(this);
+            }
+        };
+        SampleView = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        let entity = new Sample().attach(scene_1.Scene.activeScene);
+        entity.destroy();
+        update_loop_1.UpdateCycle.triggerUpdateTick(0); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(viewDestroyCount).toEqual(1);
+    });
+    (0, vitest_1.test)('triggering destroy() multiple times should not take effect multiply', () => {
+        let viewDestroyCount = 0;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            destroy() {
+                viewDestroyCount++;
+            }
+        };
+        SampleView = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample })
+        ], SampleView);
+        let entity = new Sample().attach(scene_1.Scene.activeScene);
+        entity.destroy();
+        entity.destroy();
+        update_loop_1.UpdateCycle.triggerUpdateTick(0); // Update cycle should take place to destroy functions to be called
+        (0, vitest_1.expect)(viewDestroyCount).toEqual(1);
+    });
+    (0, vitest_1.test)('update tick should update view', async () => {
+        let viewUpdateCount = 0;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            constructor(entity) {
+                super();
+            }
+            update() {
+                viewUpdateCount++;
+            }
+        };
+        SampleView = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        new Sample().attach(scene_1.Scene.activeScene);
+        await (0, helpers_lib_1.Wait)(); // wait for async view init to be completed, so views can listen update ticks
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(0);
+        update_loop_1.UpdateCycle.triggerUpdateTick(0);
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(1);
+        update_loop_1.UpdateCycle.triggerUpdateTick(0);
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(2);
+    });
+    (0, vitest_1.test)('decorator should not effect static variables', () => {
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let SampleView = class SampleView extends view_1.View {
+            static { this.test = 'test'; }
+        };
+        SampleView = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity })
+        ], SampleView);
+        (0, vitest_1.expect)(SampleView.test).toEqual('test');
+    });
+    (0, vitest_1.test)('should wait until creation and return the view object after', async () => {
+        var SampleView_4;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_4 = this; }
+            constructor(entity) {
+                super();
+                SampleView_4.instance = this;
+            }
+        };
+        SampleView = SampleView_4 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView);
+        let baseEntity = new BaseEntity().attach(scene_1.Scene.activeScene);
+        let view = await SampleView.getInstanceOrFail(baseEntity.id);
+        (0, vitest_1.expect)(SampleView.instance).toBeDefined();
+        (0, vitest_1.expect)(SampleView.instance).toEqual(view);
+    });
+    (0, vitest_1.test)('should wait until creation and return the view object after in other views init', async () => {
+        var SampleView1_1;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let SampleView2 = class SampleView2 extends view_1.View {
+            constructor(entity) {
+                super();
+                this.entity = entity;
+            }
+            async init() {
+                let view = await SampleView1.getInstanceOrFail(this.entity.id);
+                (0, vitest_1.expect)(SampleView1.instance).toBeDefined();
+                (0, vitest_1.expect)(SampleView1.instance).toEqual(view);
+            }
+        };
+        SampleView2 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView2);
+        let SampleView1 = class SampleView1 extends view_1.View {
+            static { SampleView1_1 = this; }
+            constructor(entity) {
+                super();
+                SampleView1_1.instance = this;
+            }
+            async init() {
+                await (0, helpers_lib_1.Wait)();
+            }
+        };
+        SampleView1 = SampleView1_1 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView1);
+        new BaseEntity().attach(scene_1.Scene.activeScene);
+    });
+    (0, vitest_1.test)('should wait until creation and return the view object after, case entity get created before the view definition', async () => {
+        var SampleView_5;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let baseEntity = new BaseEntity().attach(scene_1.Scene.activeScene);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_5 = this; }
+            constructor(entity) {
+                super();
+                SampleView_5.instance = this;
+            }
+        };
+        SampleView = SampleView_5 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView);
+        let view = await SampleView.getInstanceOrFail(baseEntity.id);
+        (0, vitest_1.expect)(SampleView.instance).toBeDefined();
+        (0, vitest_1.expect)(SampleView.instance).toEqual(view);
+    });
+    (0, vitest_1.test)('should wait until creation and return the view object after when there is an async init', async () => {
+        var SampleView_6;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_6 = this; }
+            constructor(entity) {
+                super();
+            }
+            async init() {
+                await (0, helpers_lib_1.Wait)();
+                SampleView_6.instance = this;
+            }
+        };
+        SampleView = SampleView_6 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView);
+        let baseEntity = new BaseEntity().attach(scene_1.Scene.activeScene);
+        let view = await SampleView.getInstanceOrFail(baseEntity.id);
+        (0, vitest_1.expect)(SampleView.instance).toBeDefined();
+        (0, vitest_1.expect)(SampleView.instance).toEqual(view);
+    });
+    (0, vitest_1.test)('should wait until creation and return the view object after when there is an async init, case entity get created before the view definition', async () => {
+        var SampleView_7;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let baseEntity = new BaseEntity().attach(scene_1.Scene.activeScene);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_7 = this; }
+            constructor(entity) {
+                super();
+            }
+            async init() {
+                await (0, helpers_lib_1.Wait)();
+                SampleView_7.instance = this;
+            }
+        };
+        SampleView = SampleView_7 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView);
+        let view = await SampleView.getInstanceOrFail(baseEntity.id);
+        (0, vitest_1.expect)(SampleView.instance).toBeDefined();
+        (0, vitest_1.expect)(SampleView.instance).toEqual(view);
+    });
+    (0, vitest_1.test)('should throw error if the entity id is belonging to another entity', async () => {
+        var SampleView_8;
+        let BaseEntity = class BaseEntity extends entity_1.Entity {
+        };
+        BaseEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], BaseEntity);
+        let baseEntity = new BaseEntity().attach(scene_1.Scene.activeScene);
+        let SampleEntity = class SampleEntity extends entity_1.Entity {
+        };
+        SampleEntity = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], SampleEntity);
+        let sampleEntity = new SampleEntity().attach(baseEntity);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_8 = this; }
+            constructor(entity) {
+                super();
+                SampleView_8.instance = this;
+            }
+        };
+        SampleView = SampleView_8 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: BaseEntity }),
+            __metadata("design:paramtypes", [BaseEntity])
+        ], SampleView);
+        (0, vitest_1.expect)(async () => await SampleView.getInstanceOrFail(sampleEntity.id)).rejects.toThrow();
+    });
+    (0, vitest_1.test)('update tick should not update view until creation is complete', () => {
+        var SampleView_9;
+        let viewUpdateCount = 0;
+        let Sample = class Sample extends entity_1.Entity {
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_9 = this; }
+            constructor(entity) {
+                super();
+                SampleView_9.instance = this;
+            }
+            async init() {
+                await (0, helpers_lib_1.Wait)();
+            }
+            update() {
+                viewUpdateCount++;
+            }
+        };
+        SampleView = SampleView_9 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        new Sample().attach(scene_1.Scene.activeScene);
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(0);
+        update_loop_1.UpdateCycle.triggerUpdateTick(0);
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(0);
+        SampleView.instance['creationIsDone']();
+        update_loop_1.UpdateCycle.triggerUpdateTick(0);
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(1);
+    });
+    (0, vitest_1.test)('once entity is destroyed, it should not take effect until view completes its cycle', async () => {
+        var Sample_1, SampleView_10;
+        let sampleAction = new actions_lib_1.Action();
+        let Sample = class Sample extends entity_1.Entity {
+            static { Sample_1 = this; }
+            static { this.triggered = false; }
+            constructor() {
+                super();
+                sampleAction
+                    .subscribe(() => {
+                    Sample_1.triggered = true;
+                    entity.destroy();
+                })
+                    .attach(this);
+            }
+            update() {
+                sampleAction.trigger();
+            }
+        };
+        Sample = Sample_1 = __decorate([
+            (0, entity_1.EntityDecorator)(),
+            __metadata("design:paramtypes", [])
+        ], Sample);
+        let SampleView = class SampleView extends view_1.View {
+            static { SampleView_10 = this; }
+            static { this.triggered = false; }
+            constructor(entity) {
+                super();
+            }
+            async init() {
+                sampleAction
+                    .subscribe(() => {
+                    SampleView_10.triggered = true;
+                })
+                    .attach(this);
+            }
+        };
+        SampleView = SampleView_10 = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], SampleView);
+        let entity = new Sample().attach(scene_1.Scene.activeScene);
+        update_loop_1.UpdateCycle.triggerUpdateTick(0);
+        (0, vitest_1.expect)(Sample.triggered).toEqual(true);
+        (0, vitest_1.expect)(SampleView.triggered).toEqual(true);
+    });
+});
+//# sourceMappingURL=view.spec.js.map

package/dist/lib/animator/animator.spec.d.ts

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