bard-legends-framework 0.10.5 → 0.10.6

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentTargetStore = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const update_cycle_1 = require("../../update-cycle");
+/** @internal */
+class AttachmentTargetStore {
+    static { this.nextAvailableIds = new Map(); }
+    static { this.attachmentTargets = new Map(); }
+    static findAttachableParent(attachableCandidate) {
+        let attachmentTarget;
+        if (helpers_lib_1.Comparator.isString(attachableCandidate)) {
+            let attachableId = attachableCandidate;
+            attachmentTarget = this.attachmentTargets.get(attachableId);
+            if (!attachmentTarget) {
+                throw new Error(`Attachable: attachable not found by id! id: ${attachableId}`);
+            }
+        }
+        else {
+            attachmentTarget = attachableCandidate;
+        }
+        return attachmentTarget;
+    }
+    static registerAttachable(attachmentTarget) {
+        let numberPartOfTheId = AttachmentTargetStore.nextAvailableIds.get(attachmentTarget.constructor.name) || 1;
+        AttachmentTargetStore.nextAvailableIds.set(attachmentTarget.constructor.name, numberPartOfTheId + 1);
+        let id = `${attachmentTarget.constructor.name}:${numberPartOfTheId}`;
+        AttachmentTargetStore.attachmentTargets.set(id, attachmentTarget);
+        return id;
+    }
+    static unregisterAttachable(attachmentTarget) {
+        AttachmentTargetStore.attachmentTargets.delete(attachmentTarget.id);
+    }
+}
+exports.AttachmentTargetStore = AttachmentTargetStore;
+update_cycle_1.UpdateCycle.hardResetAction.subscribe(() => {
+    AttachmentTargetStore['nextAvailableIds'].clear();
+    AttachmentTargetStore['attachmentTargets'].clear();
+});
+//# sourceMappingURL=attachment-target.store.js.map

package/dist/game-entities/base/helpers/decorate-actions-lib.d.ts

@@ -1,12 +1,12 @@
-import { Attachable } from '../attachable';
+import { AttachmentTarget } from '../attachment-target';
 declare module 'actions-lib' {
     interface ActionSubscription {
-        attach(parent: Attachable | string): ActionSubscription;
+        attach(parent: AttachmentTarget | string): ActionSubscription;
         attachToRoot(): ActionSubscription;
         decorateActionSubscription(): ActionSubscription;
     }
     interface ReducerEffectChannel<EffectType, ResponseType> {
-        attach(parent: Attachable | string): ReducerEffectChannel<EffectType, ResponseType>;
+        attach(parent: AttachmentTarget | string): ReducerEffectChannel<EffectType, ResponseType>;
         attachToRoot(): ReducerEffectChannel<EffectType, ResponseType>;
         decorateEffectChannel(): ReducerEffectChannel<EffectType, ResponseType>;
     }

package/dist/game-entities/base/helpers/decorate-actions-lib.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionsLibDecorator = void 0;
 const ActionsLib = __importStar(require("actions-lib"));
-const attachable_store_1 = require("./attachable.store");
+const attachment_target_store_1 = require("./attachment-target.store");
 class ActionsLibDecorator {
     static decorate(actionsLib) {
         this.decorateAttachFunctions(actionsLib);
@@ -38,7 +38,7 @@ class ActionsLibDecorator {
     }
     static decorateAttachFunctions(actionsLib) {
         actionsLib.ActionSubscription.prototype.attach = function (parent) {
-            let parentEntity = attachable_store_1.AttachableStore.findAttachableParent(parent);
+            let parentEntity = attachment_target_store_1.AttachmentTargetStore.findAttachableParent(parent);
             parentEntity['setAttachment'](this);
             this.$meta = { attachIsCalled: true, attachedParent: parentEntity };
             return this;
@@ -61,7 +61,7 @@ class ActionsLibDecorator {
             return originalCombine(subscriptions);
         };
         actionsLib.ReducerEffectChannel.prototype.attach = function (parent) {
-            let parentEntity = attachable_store_1.AttachableStore.findAttachableParent(parent);
+            let parentEntity = attachment_target_store_1.AttachmentTargetStore.findAttachableParent(parent);
             parentEntity['setAttachment'](this);
             this.$meta = { attachIsCalled: true, attachedParent: parentEntity };
             return this;

package/dist/game-entities/base/helpers/referance-variable.d.ts

@@ -1,5 +1,5 @@
 import { ActionListenerCallbackFunction, ActionSubscription, IVariable } from 'actions-lib';
-import { Attachable } from '../attachable';
+import { AttachmentTarget } from '../attachment-target';
 export declare class ReferanceVariable implements IVariable<string | undefined> {
     private options;
     private variable;
@@ -8,7 +8,7 @@ export declare class ReferanceVariable implements IVariable<string | undefined>
     set value(value: string | undefined);
     get listenerCount(): number;
     constructor(options: {
-        attachTo: Attachable;
+        attachTo: AttachmentTarget;
     });
     set(data: string | undefined): this;
     subscribe(callback: ActionListenerCallbackFunction<string | undefined>): ActionSubscription;

package/dist/game-entities/base/helpers/referance-variable.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferanceVariable = void 0;
 const actions_lib_1 = require("actions-lib");
-const attachable_store_1 = require("./attachable.store");
+const attachment_target_store_1 = require("./attachment-target.store");
 class ReferanceVariable {
     get value() {
         return this.variable.value;
@@ -22,7 +22,7 @@ class ReferanceVariable {
             this.destroySubscription?.unsubscribe();
             this.destroySubscription = undefined;
             if (data) {
-                this.destroySubscription = attachable_store_1.AttachableStore.findAttachableParent(data)
+                this.destroySubscription = attachment_target_store_1.AttachmentTargetStore.findAttachableParent(data)
                     .onDestroy.subscribe(() => {
                     this.set(undefined);
                 })

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

@@ -1,14 +1,14 @@
-import { Action, Variable } from 'actions-lib';
-export interface IDestroyable {
-    destroy(): void;
-}
-export interface IAttachable {
+import { Action } from 'actions-lib';
+export interface IAttachmentTarget {
     readonly id: string;
     readonly onDestroy: Action<void>;
-    setAttachment(child: CanBeAttached): void;
-    removeAttachment(child: CanBeAttached): void;
+    setAttachment(child: IAttachable): void;
+    removeAttachment(child: IAttachable): void;
+}
+export interface IDestroyable {
+    destroy(): void;
 }
 export interface IUnsubscribable {
     unsubscribe(...args: any[]): void;
 }
-export type CanBeAttached = IDestroyable | IUnsubscribable | CanBeAttached[] | Variable<CanBeAttached>;
+export type IAttachable = IDestroyable | IUnsubscribable;

package/dist/game-entities/entity/entity.d.ts

@@ -1,14 +1,14 @@
-import { Attachable } from '../base/attachable';
+import { AttachmentTarget } from '../base/attachment-target';
 export type EntityClassType = new (...args: any[]) => Entity;
 export declare function EntityDecorator(): (EntityClass: EntityClassType) => any;
-export declare abstract class Entity extends Attachable {
+export declare abstract class Entity extends AttachmentTarget {
     static getInstanceById<T extends Entity>(this: new (...args: any[]) => T, entityId: string | undefined): T | undefined;
     static getInstanceByIdOrFail<T extends Entity>(this: new (...args: any[]) => T, entityId: string): T;
     static getEntities<T extends Entity>(this: new (...args: any[]) => T): T[];
     private viewCreationHelper;
     constructor();
+    destroy(): void;
     protected destroySelf(): void;
-    attach(parent: Attachable | string): this;
+    attach(parent: AttachmentTarget | string): this;
     attachToRoot(): this;
-    update(time: number, delta: number): void;
 }

package/dist/game-entities/entity/entity.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = exports.EntityDecorator = void 0;
-const attachable_1 = require("../base/attachable");
+const attachment_target_1 = require("../base/attachment-target");
 const update_cycle_1 = require("../update-cycle");
 const entity_store_helper_1 = require("./helpers/entity-store.helper");
 const entity_views_helper_1 = require("./helpers/entity-views.helper");
@@ -14,7 +14,7 @@ function EntityDecorator() {
     };
 }
 exports.EntityDecorator = EntityDecorator;
-class Entity extends attachable_1.Attachable {
+class Entity extends attachment_target_1.AttachmentTarget {
     static getInstanceById(entityId) {
         if (entityId) {
             return entity_store_helper_1.EntityStoreHelper.getIdToEntityMap(this).get(entityId);
@@ -43,21 +43,28 @@ class Entity extends attachable_1.Attachable {
         })
             .attach(this);
     }
+    // make the destroy function non-internal
+    destroy() {
+        super.destroy();
+    }
     destroySelf() {
         super.destroySelf();
         this.viewCreationHelper.destroyViews();
         entity_store_helper_1.EntityStoreHelper.unregisterEntity(this.constructor.name, this.id);
     }
+    // make the destroy function non-internal
     attach(parent) {
         super.attach(parent);
         this.viewCreationHelper.createViews();
         return this;
     }
+    // make the destroy function non-internal
     attachToRoot() {
         super.attachToRoot();
         this.viewCreationHelper.createViews();
         return this;
     }
+    /** @internal */
     update(time, delta) { }
 }
 exports.Entity = Entity;

package/dist/game-entities/entity/entity.test.js

@@ -45,11 +45,14 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
     (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(undefined);
+        SampleScene.open();
     });
     (0, vitest_1.test)('entities should have ids', () => {
         let Sample = class Sample extends entity_1.Entity {
@@ -191,15 +194,18 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
         (0, vitest_1.expect)(Sample.getEntities()).toEqual([sample1, sample2]);
     });
     (0, vitest_1.test)('lifecycle events', async () => {
+        scene_1.Scene.activeScene.set(undefined);
         let callStack = [];
         let SampleScene = class SampleScene extends scene_1.Scene {
             constructor() {
                 super();
                 callStack.push('scene constructor');
             }
+            async init() { }
             update() {
                 callStack.push('scene update');
             }
+            async prepareToClose() { }
             afterDestroy() {
                 callStack.push('scene destroy');
             }
@@ -209,6 +215,9 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
             __metadata("design:paramtypes", [])
         ], SampleScene);
         let OtherScene = class OtherScene extends scene_1.Scene {
+            async init() { }
+            update() { }
+            async prepareToClose() { }
         };
         OtherScene = __decorate([
             (0, scene_1.SceneDecorator)()
@@ -245,13 +254,15 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
             (0, view_1.ViewDecorator)({ entity: Sample }),
             __metadata("design:paramtypes", [Sample])
         ], _SampleView);
-        SampleScene.open(undefined);
+        SampleScene.open();
         await (0, helpers_lib_1.Wait)(); // Wait for the async scene open to be done
         await update_cycle_1.UpdateCycle.triggerUpdateTick(1);
         new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
         await (0, helpers_lib_1.Wait)(); // Wait for the async view init to expect the update call
         await update_cycle_1.UpdateCycle.triggerUpdateTick(1);
-        OtherScene.open(undefined);
+        SampleScene.getInstanceOrFail().close();
+        await (0, helpers_lib_1.Wait)(); // Wait for the async scene close to be done
+        OtherScene.open();
         await (0, helpers_lib_1.Wait)(); // Wait for the async scene open to be done
         await update_cycle_1.UpdateCycle.triggerUpdateTick(1); // Update cycle should take place to destroy functions to be called
         (0, vitest_1.expect)(callStack).toEqual([

package/dist/game-entities/entity/singleton-entity.d.ts

@@ -1,15 +1,6 @@
-import { ActionSubscription } from 'actions-lib';
 import { Entity } from './entity';
 export declare abstract class SingletonEntity extends Entity {
-    private static onSingletonCreated;
     static getInstance<T extends SingletonEntity>(this: new (...args: any[]) => T): T | undefined;
     static getInstanceOrFail<T extends SingletonEntity>(this: new (...args: any[]) => T): T;
-    static getInstanceAsync<T extends SingletonEntity>(this: new (...args: any[]) => T): Promise<T>;
-    /**
-     * Listens the singleton entity continuesly.
-     * The subscribe function should return the subscription made to the entity, becaues it needs to be destroyed each time entity gets destroyed.
-     * Use ActionSubscription.combine([...]) if there are more than one subscription.
-     */
-    static continuesSubscription<T extends SingletonEntity>(this: new (...args: any[]) => T, subscribeFunction: (entity: T) => ActionSubscription): ActionSubscription;
     constructor();
 }

package/dist/game-entities/entity/singleton-entity.js

@@ -1,67 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingletonEntity = void 0;
-const actions_lib_1 = require("actions-lib");
 const entity_1 = require("./entity");
 const entity_store_helper_1 = require("./helpers/entity-store.helper");
 class SingletonEntity extends entity_1.Entity {
-    static { this.onSingletonCreated = new actions_lib_1.Action(); }
     static getInstance() {
         return entity_store_helper_1.EntityStoreHelper.getSingleton(this);
     }
     static getInstanceOrFail() {
         return entity_store_helper_1.EntityStoreHelper.getSingletonOrFail(this);
     }
-    static async getInstanceAsync() {
-        let entity = entity_store_helper_1.EntityStoreHelper.getSingleton(this);
-        if (entity && !entity.destroyed) {
-            return entity;
-        }
-        else {
-            return new Promise(resolve => {
-                let subscription = SingletonEntity.onSingletonCreated
-                    .subscribe(createdEntity => {
-                    if (createdEntity instanceof this) {
-                        subscription.unsubscribe();
-                        resolve(createdEntity);
-                    }
-                })
-                    .attachToRoot();
-            });
-        }
-    }
-    /**
-     * Listens the singleton entity continuesly.
-     * The subscribe function should return the subscription made to the entity, becaues it needs to be destroyed each time entity gets destroyed.
-     * Use ActionSubscription.combine([...]) if there are more than one subscription.
-     */
-    static continuesSubscription(subscribeFunction) {
-        let unsubscribed = false;
-        let subscription;
-        let onDestroySubscription;
-        let subscribe = () => {
-            this.getSingletonAsync().then((entity) => {
-                if (!unsubscribed) {
-                    subscription = subscribeFunction(entity);
-                    onDestroySubscription = entity.onDestroy
-                        .subscribe(() => {
-                        if (!unsubscribed) {
-                            subscription?.unsubscribe();
-                            onDestroySubscription?.unsubscribe();
-                            subscribe();
-                        }
-                    })
-                        .attachToRoot();
-                }
-            });
-        };
-        subscribe();
-        return new actions_lib_1.ActionSubscription(() => {
-            unsubscribed = true;
-            subscription?.unsubscribe();
-            onDestroySubscription?.unsubscribe();
-        }).decorateActionSubscription();
-    }
     constructor() {
         super();
         let entities = this.constructor.getEntities();
@@ -69,9 +17,6 @@ class SingletonEntity extends entity_1.Entity {
             this.attachToRoot();
             throw new Error(`SingletonEntity: entity is decorated as singleton but multiple instances are created! Name: "${this.constructor.name}"`);
         }
-        else {
-            SingletonEntity.onSingletonCreated.trigger(this);
-        }
     }
 }
 exports.SingletonEntity = SingletonEntity;

package/dist/game-entities/entity/singleton-entity.test.js

@@ -41,11 +41,14 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
     (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(undefined);
+        SampleScene.open();
     });
     (0, vitest_1.test)('select singleton sample', () => {
         let Sample = class Sample extends singleton_entity_1.SingletonEntity {

package/dist/game-entities/index.d.ts

@@ -1,5 +1,5 @@
 export { Attachable } from './base/attachable';
-export { Destroyable } from './base/destroyable';
+export { AttachmentTarget } from './base/attachment-target';
 export { ActionsLibDecorator } from './base/helpers/decorate-actions-lib';
 export { ReferanceVariable } from './base/helpers/referance-variable';
 export * from './base/interfaces';

package/dist/game-entities/index.js

@@ -14,11 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewDecorator = exports.View = exports.UpdateCycle = exports.ServiceDecorator = exports.Service = exports.SceneDecorator = exports.Scene = exports.SingletonEntity = exports.EntityDecorator = exports.Entity = exports.ControllerLink = exports.ControllerDecorator = exports.ReferanceVariable = exports.ActionsLibDecorator = exports.Destroyable = exports.Attachable = void 0;
+exports.ViewDecorator = exports.View = exports.UpdateCycle = exports.ServiceDecorator = exports.Service = exports.SceneDecorator = exports.Scene = exports.SingletonEntity = exports.EntityDecorator = exports.Entity = exports.ControllerLink = exports.ControllerDecorator = exports.ReferanceVariable = exports.ActionsLibDecorator = exports.AttachmentTarget = exports.Attachable = void 0;
 var attachable_1 = require("./base/attachable");
 Object.defineProperty(exports, "Attachable", { enumerable: true, get: function () { return attachable_1.Attachable; } });
-var destroyable_1 = require("./base/destroyable");
-Object.defineProperty(exports, "Destroyable", { enumerable: true, get: function () { return destroyable_1.Destroyable; } });
+var attachment_target_1 = require("./base/attachment-target");
+Object.defineProperty(exports, "AttachmentTarget", { enumerable: true, get: function () { return attachment_target_1.AttachmentTarget; } });
 var decorate_actions_lib_1 = require("./base/helpers/decorate-actions-lib");
 Object.defineProperty(exports, "ActionsLibDecorator", { enumerable: true, get: function () { return decorate_actions_lib_1.ActionsLibDecorator; } });
 var referance_variable_1 = require("./base/helpers/referance-variable");

package/dist/game-entities/scene/scene.d.ts

@@ -1,20 +1,27 @@
 import { Variable } from 'actions-lib';
-import { Attachable } from '../base/attachable';
-export type SceneClassType = new (...services: any[]) => Scene<any>;
+import { AttachmentTarget } from '../base/attachment-target';
+export type SceneClassType = new (...services: unknown[]) => Scene<unknown, unknown>;
+type SceneInput<T> = T extends Scene<infer I, any> ? I : never;
+type SceneOutput<T> = T extends Scene<any, infer O> ? O : never;
 export declare function SceneDecorator(): (SceneClass: SceneClassType) => any;
-export declare abstract class Scene<InputType> extends Attachable {
-    private static sceneInstance?;
+export declare abstract class Scene<InputType, OutputType> extends AttachmentTarget {
     private static sceneTransitioning;
-    static activeScene: Variable<Scene<any> | undefined>;
-    static getActiveSceneOrFail(): Scene<any>;
-    static isActive<T extends Scene<any>>(this: new (...args: any[]) => T): boolean;
-    static getInstance<T extends Scene<any>>(this: new (...args: any[]) => T): T | undefined;
-    static getInstanceOrFail<T extends Scene<any>>(this: new (...args: any[]) => T): T;
-    static open<InputType>(this: new (...args: any[]) => Scene<InputType>, input: InputType): Promise<void>;
-    static close(): Promise<void>;
+    static activeScene: Variable<Scene<unknown, unknown> | undefined>;
+    static getActiveScene(this: typeof Scene): Scene<unknown, unknown> | undefined;
+    static getActiveSceneOrFail(this: typeof Scene): Scene<unknown, unknown>;
+    static isActive<T extends Scene<unknown, unknown>>(this: new (...args: unknown[]) => T): boolean;
+    static getInstance<T extends Scene<unknown, unknown>>(this: new (...args: unknown[]) => T): T | undefined;
+    static getInstanceOrFail<T extends Scene<unknown, unknown>>(this: new (...args: unknown[]) => T): T;
+    static open<T extends Scene<any, any>>(this: new (...args: unknown[]) => T, ...args: T extends Scene<void, any> ? [] : [SceneInput<T>]): {
+        readonly onOpen: Promise<void>;
+        readonly onClose: Promise<SceneOutput<T>>;
+    };
+    private closePromise;
+    private resolveClosePromise;
     constructor();
-    protected destroySelf(): void;
-    protected init(input: InputType): Promise<void>;
-    protected update(time: number, delta: number): void;
-    protected prepareToClose(): Promise<void>;
+    close(...args: OutputType extends void ? [] : [OutputType]): Promise<void>;
+    protected abstract init(input: InputType): Promise<void>;
+    protected abstract update(time: number, delta: number): void;
+    protected abstract prepareToClose(): Promise<void>;
 }
+export {};

package/dist/game-entities/scene/scene.js

@@ -2,71 +2,77 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scene = exports.SceneDecorator = void 0;
 const actions_lib_1 = require("actions-lib");
-const attachable_1 = require("../base/attachable");
+const attachment_target_1 = require("../base/attachment-target");
 const service_1 = require("../service/service");
 const update_cycle_1 = require("../update-cycle");
 function SceneDecorator() {
     return function (SceneClass) {
         SceneClass.$meta = {
-            paramtypes: service_1.Service.getParametersMeta(SceneClass),
+            paramtypes: service_1.Service['getParametersMeta'](SceneClass),
             type: 'scene'
         };
         return SceneClass;
     };
 }
 exports.SceneDecorator = SceneDecorator;
-class Scene extends attachable_1.Attachable {
+class Scene extends attachment_target_1.AttachmentTarget {
     static { this.sceneTransitioning = false; }
     static { this.activeScene = new actions_lib_1.Variable(); }
+    static getActiveScene() {
+        return Scene.activeScene.value;
+    }
     static getActiveSceneOrFail() {
-        if (!Scene.sceneInstance) {
+        if (!Scene.activeScene.value) {
             throw new Error(`Scene: getActiveSceneOrFail is called when there is no active scene!`);
         }
-        return Scene.sceneInstance;
+        return Scene.activeScene.value;
     }
     static isActive() {
-        return Scene.sceneInstance instanceof this;
+        return Scene.activeScene.value instanceof this;
     }
     static getInstance() {
-        return Scene.sceneInstance instanceof this ? Scene.sceneInstance : undefined;
+        return Scene.activeScene.value instanceof this ? Scene.activeScene.value : undefined;
     }
     static getInstanceOrFail() {
-        if (!Scene.sceneInstance) {
+        if (!Scene.activeScene.value) {
             throw new Error(`Scene: getInstance is called when there is no active scene!`);
         }
-        if (!(Scene.sceneInstance instanceof this)) {
-            throw new Error(`Scene: getInstance is called while "${this.name}" was not the active scene. Current scene is: "${Scene.sceneInstance.constructor.name}"!`);
+        if (!(Scene.activeScene.value instanceof this)) {
+            throw new Error(`Scene: getInstance is called while "${this.name}" was not the active scene. Current scene is: "${Scene.activeScene.value.constructor.name}"!`);
         }
-        return Scene.sceneInstance;
+        return Scene.activeScene.value;
     }
-    static async open(input) {
-        if (!Scene.sceneTransitioning) {
-            Scene.sceneTransitioning = true;
-            if (Scene.sceneInstance) {
-                await Scene.sceneInstance.prepareToClose();
-                Scene.sceneInstance.destroy();
-                Scene.sceneInstance = undefined;
-                Scene.activeScene.set(undefined);
-            }
-            let resolvedArgs = service_1.Service.resolveParameters([], this.$meta.paramtypes);
-            let scene = new this(...resolvedArgs);
-            Scene.sceneInstance = scene;
-            Scene.activeScene.set(scene);
-            await scene.init(input);
-            Scene.sceneTransitioning = false;
+    static open(...args) {
+        if (Scene.sceneTransitioning) {
+            throw new Error('Scene: you cannot open a scene while a scene is transitioning!');
         }
-    }
-    static async close() {
-        if (Scene.sceneInstance) {
-            await Scene.sceneInstance.prepareToClose();
-            Scene.sceneInstance.destroy();
-            Scene.sceneInstance = undefined;
-            Scene.activeScene.set(undefined);
+        else if (Scene.activeScene.value) {
+            throw new Error('Scene: you cannot open a scene while there is already another active scene!');
         }
+        let input = args[0];
+        let onOpenResolve;
+        let onCloseResolve;
+        let onOpen = new Promise((resolve, reject) => {
+            onOpenResolve = resolve;
+        });
+        let onClose = new Promise((resolve, reject) => {
+            onCloseResolve = resolve;
+        });
+        Scene.sceneTransitioning = true;
+        let resolvedArgs = service_1.Service['resolveParameters']([], this.$meta.paramtypes);
+        let scene = new this(...resolvedArgs).attachToRoot();
+        Scene.activeScene.set(scene);
+        scene.init(input).then(() => {
+            Scene.sceneTransitioning = false;
+            onOpenResolve();
+        });
+        scene.closePromise.then(output => {
+            onCloseResolve(output);
+        });
+        return { onOpen, onClose };
     }
     constructor() {
         super();
-        this.attachToRoot(); // Scene is always attached to itself
         update_cycle_1.UpdateCycle.sceneUpdateAction
             .subscribe(updateData => {
             if (!this.destroyed) {
@@ -74,16 +80,26 @@ class Scene extends attachable_1.Attachable {
             }
         })
             .attach(this);
+        this.closePromise = new Promise(resolve => (this.resolveClosePromise = resolve));
     }
-    destroySelf() {
-        super.destroySelf();
+    async close(...args) {
+        if (Scene.sceneTransitioning) {
+            throw new Error('Scene: you cannot close a scene while a scene is transitioning!');
+        }
+        else if (Scene.activeScene.value !== this) {
+            throw new Error('Internal Error: Scene instance is accessed while it is not the active scene!');
+        }
+        let output = args[0];
+        Scene.sceneTransitioning = true;
+        await this.prepareToClose();
+        super.destroy();
+        Scene.activeScene.set(undefined);
+        this.resolveClosePromise(output);
+        Scene.sceneTransitioning = false;
     }
-    async init(input) { }
-    update(time, delta) { }
-    async prepareToClose() { }
 }
 exports.Scene = Scene;
 update_cycle_1.UpdateCycle.hardResetAction.subscribe(() => {
-    Scene['sceneInstance'] = undefined;
+    Scene.activeScene.set(undefined);
 });
 //# sourceMappingURL=scene.js.map