mani-game-engine 1.0.0-pre.5 → 1.0.0-pre.51

package/src/scope/scopeContext.ts

@@ -1,267 +1,380 @@
-import {Class, EcsInjector, Signal} from '../index';
-import {ID, putIfAbsent} from 'mani-injector';
-import {SignalBinding} from 'mani-signal';
-import {signalHandlers} from '../ecsInjector';
-import {SignalCallback} from 'mani-signal/src/signal';
-
-export type ScopeSignalOptions = { keepAlive?: boolean | Scope[], group?: string }
-
-export const scopeSignalHandlers = new Map<Object, [string, ID, ScopeSignalOptions?][]>();
-
-export const OnScopeSignal = (id: ID, options?: ScopeSignalOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
-    if (target instanceof Function) {
-        throw new Error('only allowed on non static methods');
-    } else {
-        const mappingList = putIfAbsent(scopeSignalHandlers, target.constructor, (): [string, ID, ScopeSignalOptions?][] => []);
-        mappingList.push([propertyKey, id, options]);
-    }
-};
-
-export interface Scope {
-    [propName: string]: any; // disable weak type detection
-    onEnter?(): void;
-    onExit?(): void;
-    onSubReturn?(): void;
-    onSubExit?(): void;
-    onActivate?(): void;
-    onDeactivate?(): void;
-}
-
-class ScopeSignalBinding {
-    readonly keepAlive?: boolean | Scope[];
-    private group?: string;
-
-    constructor(private signalBinding: SignalBinding, options?: ScopeSignalOptions) {
-        this.keepAlive = options?.keepAlive;
-        this.group = options?.group;
-    }
-
-    activate() {
-        this.signalBinding.setActive(true);
-    }
-
-    deactivate() {
-        this.signalBinding.setActive(false);
-    }
-
-    detach() {
-        this.signalBinding.detach();
-    }
-}
-
-class ScopeStack {
-    readonly stack: ScopeContext[] = [];
-
-    constructor(readonly rootScope: ScopeContext) {
-        this.stack.push(rootScope);
-    }
-
-    get rootContext() {
-        return this.stack[0];
-    }
-
-    get activeContext() {
-        return this.stack[this.stack.length - 1];
-    }
-
-}
-
-export type ScopeMapping = (params: {
-    injector: EcsInjector,
-    registerScopeService: (serviceClass: Class) => void,
-}) => void
-
-interface AddScopeSignalOptions extends ScopeSignalOptions {
-    context?: unknown;
-}
-
-// TODO: maybe move Signal resolver to Injector and dont use EcsInjector here?
-export class ScopeContext {
-    readonly scope: Scope;
-    readonly injector: EcsInjector;
-    private readonly stack: ScopeStack; // TODO: naming
-    private readonly signalBindings: ScopeSignalBinding[] = [];
-
-    // Scope services will be active (signals bounds) in this scope and all sub scopes
-    // when this scope exits, the signals will be unbound
-    private serviceBindings: SignalBinding[] = [];
-    private closed = false;
-    private muteKeepAliveSignals = false;
-
-    constructor(injector: EcsInjector, scopeClass: Class, mapping?: ScopeMapping, private parent?: ScopeContext) {
-        if (!parent) {
-            this.stack = new ScopeStack(this);
-
-        } else {
-            this.stack = parent.stack;
-            this.stack.stack.push(this);
-        }
-
-        this.injector = injector.createChild();
-        //TODO: i think it would really be better if we implement an injector.injectIntoUnmapped() instead of mapping here
-        this.injector.map(scopeClass).toSingleton();
-        this.injector.map(ScopeContext).toValue(this);
-
-        mapping?.({
-            injector: this.injector,
-            registerScopeService: serviceClass => {
-                this.injector.map(serviceClass).toSingleton();
-                this.mapServiceSignals(this.injector.get(serviceClass));
-            },
-        });
-
-        this.scope = this.injector.get(scopeClass) as Scope;
-        this.mapScopeSignals();
-        this.updateSignalBindings();
-        // TODO: maybe the scope needs to prepare resources or something before it can react to signals, so we should move onEnter bevore the signal mapping and make it async (not working in constructor though)
-        this.scope.onEnter?.();
-        this.scope.onActivate?.();
-    }
-
-    get isRoot() {
-        return this === this.stack.rootScope;
-    }
-
-    get isActive() {
-        return this === this.stack.activeContext;
-    }
-
-    get activeContext() { return this.stack.activeContext;}
-
-    enterScope(scopeClass: Class, mapping?: ScopeMapping) {
-        this.activeContext.scope.onSubExit?.();
-        this.activeContext.scope.onDeactivate?.();
-
-        const newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext);
-
-        this.logStack();
-        return newContext;
-    }
-
-    /**
-     * Exits this scope (and all open subscopes=), if a scope class is given. all scopes from the stack are closed until after the scope with the given class
-     */
-    exitScope(target?: Scope) {
-        if (this.closed) throw new Error(`Scope already closed`);
-        // TODO: check if target is in stack?
-        if (!target) target = this.scope.constructor;
-        while (true) {
-            const ctx = this.stack.stack.pop();
-            if (!ctx) {
-                throw new Error('no scope in stack');
-            }
-            ctx.exitThis();
-            if (ctx.scope.constructor === target) {
-                break;
-            }
-        }
-    }
-
-    closeSubScopes() {
-        while (!this.isActive) {
-            const ctx = this.stack.stack.pop();
-            if (!ctx) {
-                throw new Error('no scope in stack');
-            }
-            ctx.exitThis();
-        }
-    }
-
-    private logStack() {
-        console.debug('%c' + this.stack.stack.map(c => c.scope.constructor.name).join(' >> '), 'color:yellow');
-    }
-
-    getStackClasses(): Scope[] {
-        return this.stack.stack.map(context => context.scope.constructor);
-    }
-
-    addScopeSignal<T>(signal: Signal<T>, callback: SignalCallback<T>, params?: AddScopeSignalOptions) {
-        const signalBinding = new ScopeSignalBinding(signal.add(callback, params?.context), params);
-        this.signalBindings.push(signalBinding);
-    }
-
-    disableKeepAliveSignals() {
-        this.muteKeepAliveSignals = true;
-        this.updateSignalBindings();
-    }
-
-    enableKeepAliveSignals() {
-        this.muteKeepAliveSignals = false;
-        this.updateSignalBindings();
-    }
-
-    private updateSignalBindings(muteKeepAlive = false) {
-        for (const binding of this.signalBindings) {
-            if (this.isActive) {
-                binding.activate();
-            } else if (muteKeepAlive) {
-                binding.deactivate();
-            } else if (binding.keepAlive === true) {
-                binding.activate();
-            } else if (!!(binding.keepAlive)) {
-                // is array of scopes
-                // OPT: cache active context?
-                if (binding.keepAlive.indexOf(this.activeContext.scope.constructor) != -1) {
-                    binding.activate();
-                } else {
-                    binding.deactivate();
-                }
-            } else {
-                binding.deactivate();
-            }
-        }
-        muteKeepAlive = muteKeepAlive || this.muteKeepAliveSignals;
-        this.parent?.updateSignalBindings(muteKeepAlive);
-    }
-
-    private detachSignalBindings() {
-        for (const signalBinding of this.signalBindings) {
-            signalBinding.detach();
-        }
-    }
-
-    private mapScopeSignals() {
-        const handlers = scopeSignalHandlers.get(this.scope.constructor);
-        if (!handlers) return;
-
-        for (const [field, id, options] of handlers) {
-            const signal = this.injector.getSignal(id);
-            const callback = (<any>this.scope) [field];
-            this.addScopeSignal(signal, callback, {...options, context: this.scope});
-        }
-    }
-
-    private mapServiceSignals(scopeService: Object) {
-        const handlers = signalHandlers.get(scopeService.constructor);
-        if (!handlers) return;
-
-        for (const [field, id] of handlers) {
-            const signal = this.injector.getSignal(id);
-            const signalBinding = signal.add((<any>scopeService) [field], scopeService);
-            this.serviceBindings.push(signalBinding);
-        }
-    }
-
-    private detachServiceBindings() {
-        for (const binding of this.serviceBindings) {
-            binding.detach();
-        }
-        this.serviceBindings = [];
-    }
-
-    private exitThis() {
-        if (!this.parent) {
-            throw new Error('can\'t exit root scope?!');
-        }
-        this.detachSignalBindings();
-        this.detachServiceBindings();
-        this.scope.onDeactivate?.();
-        this.scope.onExit?.();
-        this.parent.updateSignalBindings();
-        this.parent.scope.onSubReturn?.();
-        this.parent.scope.onActivate?.();
-        this.closed = true;
-        this.logStack();
-    }
-
-}
+import {Class, EcsInjector, Signal, SignalBinding, SignalCallback} from '../index';
+import {signalHandlers} from '../ecsInjector';
+import {ID, putIfAbsent} from '../injector';
+
+export type ScopeSignalOptions = { keepAlive?: boolean | Scope[], group?: string }
+
+export const scopeSignalHandlers = new Map<Object, [string, ID, ScopeSignalOptions?][]>();
+
+export const OnScopeSignal = (id: ID, options?: ScopeSignalOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    if (target instanceof Function) {
+        throw new Error('only allowed on non static methods');
+    } else {
+        const mappingList = putIfAbsent(scopeSignalHandlers, target.constructor, (): [string, ID, ScopeSignalOptions?][] => []);
+        mappingList.push([propertyKey, id, options]);
+    }
+};
+
+export const SCOPE_CONTEXT = {
+    log: true,
+};
+
+export interface Scope {
+    [propName: string]: any; // disable weak type detection
+    onEnter?(): void;
+    onExit?(): void;
+    onSubReturn?(): void;
+    onSubExit?(): void;
+    onActivate?(): void;
+    onDeactivate?(): void;
+}
+
+class ScopeSignalBinding {
+    readonly keepAlive?: boolean | Scope[];
+    private group?: string;
+
+    constructor(private signalBinding: SignalBinding, options?: ScopeSignalOptions) {
+        this.keepAlive = options?.keepAlive;
+        this.group = options?.group;
+    }
+
+    activate() {
+        this.signalBinding.setActive(true);
+    }
+
+    deactivate() {
+        this.signalBinding.setActive(false);
+    }
+
+    detach() {
+        this.signalBinding.detach();
+    }
+}
+
+class ScopeStack {
+    readonly stack: ScopeContext[] = [];
+    queuedScopeChanges: (() => Promise<void>)[] = [];
+    ongoingChange = false;
+    target?: Scope;
+
+    constructor(readonly rootScope: ScopeContext) {
+        this.stack.push(rootScope);
+    }
+
+    get rootContext() {
+        return this.stack[0];
+    }
+
+    get activeContext() {
+        return this.stack[this.stack.length - 1];
+    }
+
+}
+
+export type ScopeMapping = (params: {
+    injector: EcsInjector,
+    registerScopeService: (serviceClass: Class) => void,
+    onEnter: Signal<ScopeContext>,
+    onExit: Signal<ScopeContext>,
+    onSubReturn: Signal<ScopeContext>,
+    onSubExit: Signal<ScopeContext>,
+    onActivate: Signal<ScopeContext>,
+    onDeactivate: Signal<ScopeContext>,
+
+}) => any | Promise<void>;
+
+interface AddScopeSignalOptions extends ScopeSignalOptions {
+    context?: unknown;
+}
+
+// TODO: maybe move Signal resolver to Injector and dont use EcsInjector here?
+export class ScopeContext {
+    readonly scope!: Scope;
+    readonly injector: EcsInjector;
+    private readonly stack: ScopeStack; // TODO: naming
+    private readonly signalBindings: ScopeSignalBinding[] = [];
+
+    // Scope services will be active (signals bounds) in this scope and all sub scopes
+    // when this scope exits, the signals will be unbound
+    private serviceBindings: SignalBinding[] = [];
+    private closed = false;
+    private muteKeepAliveSignals = false;
+
+    readonly onEnter = new Signal<ScopeContext>();
+    readonly onExit = new Signal<ScopeContext>();
+    readonly onSubReturn = new Signal<ScopeContext>();
+    readonly onSubExit = new Signal<ScopeContext>();
+    readonly onActivate = new Signal<ScopeContext>();
+    readonly onDeactivate = new Signal<ScopeContext>();
+    private readonly creationTime: DOMHighResTimeStamp;
+
+    get runtime() {
+        return (performance.now() - this.creationTime) / 1000;
+    }
+
+    constructor(injector: EcsInjector, scopeClass: Class, mapping?: ScopeMapping, private parent?: ScopeContext, resolve?: () => void) {
+        this.creationTime = performance.now();
+        if (!parent) {
+            this.stack = new ScopeStack(this);
+
+        } else {
+            this.stack = parent.stack;
+            this.stack.stack.push(this);
+        }
+
+        // TODO: disable this for the rootscope?
+        this.injector = injector.createChild();
+
+        //TODO: i think it would really be better if we implement an injector.injectIntoUnmapped() instead of mapping here
+        this.injector.map(scopeClass).toSingleton();
+        this.injector.map(ScopeContext).toValue(this);
+
+        const result = mapping?.({
+            injector: this.injector,
+            registerScopeService: serviceClass => {
+                this.injector.map(serviceClass).toSingleton();
+                this.mapServiceSignals(this.injector.get(serviceClass));
+            },
+            onEnter: this.onEnter,
+            onExit: this.onExit,
+            onSubReturn: this.onSubReturn,
+            onSubExit: this.onSubExit,
+            onActivate: this.onActivate,
+            onDeactivate: this.onDeactivate,
+        });
+
+        const completeScopeChange = () => {
+            (this.scope as Scope) = this.injector.get(scopeClass);
+            this.mapScopeSignals();
+            this.updateSignalBindings();
+            // TODO: maybe the scope needs to prepare resources or something before it can react to signals, so we should move onEnter bevore the signal mapping and make it async (not working in constructor though)
+            this.scope.onEnter?.();
+            this.onEnter.dispatch(this);
+            this.scope.onActivate?.();
+            this.onActivate.dispatch(this);
+            resolve?.();
+        };
+
+        if (result instanceof Promise) {
+            result.then(completeScopeChange);
+        } else {
+            completeScopeChange();
+        }
+    }
+
+    get isRoot() {
+        return this === this.stack.rootScope;
+    }
+
+    // TODO: test this
+    get target() {
+        return this.stack.target;
+    }
+
+    get isActive() {
+        return this === this.stack.activeContext;
+    }
+
+    get activeContext() { return this.stack.activeContext;}
+
+    /**
+     * returns the new scope only if there is currently no ongoing scope change happening
+     * @param scopeClass
+     * @param mapping
+     */
+    async enterScope(scopeClass: Class, mapping?: ScopeMapping) {
+        let newContext: ScopeContext | undefined;
+        const doChange = async () => {
+
+            this.activeContext.scope.onSubExit?.();
+            this.activeContext.onSubExit.dispatch(this);
+            this.activeContext.scope.onDeactivate?.();
+            this.activeContext.onDeactivate.dispatch(this);
+
+            await new Promise<void>(resolve => {
+                newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext, resolve);
+            });
+
+            this.logStack();
+            const nextChange = this.stack.queuedScopeChanges.shift();
+            if (nextChange) {
+                await nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+        };
+        // TODO: this queued changes are somewhat experimental
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            await doChange();
+        } else {
+            this.stack.queuedScopeChanges.push(doChange);
+        }
+        return newContext;
+    }
+
+    /**
+     * Exits this scope (and all open subscopes=), if a scope class is given. all scopes from the stack are closed until after the scope with the given class
+     */
+    async exitScope(target?: Scope) {
+        const doChange = async () => {
+            if (this.closed) throw new Error(`Scope already closed`);
+            // TODO: check if target is in stack?
+            this.stack.target = target || this.scope.constructor;
+            while (true) {
+                const ctx = this.stack.stack.pop();
+                if (!ctx) {
+                    throw new Error('no scope in stack');
+                }
+                ctx!.exitThis();
+                if (ctx!.scope.constructor === this.stack.target) {
+                    break;
+                }
+            }
+            this.stack.target = undefined;
+            const nextChange = this.stack.queuedScopeChanges.shift();
+            if (nextChange) {
+                await nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+
+        };
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            await doChange();
+        } else {
+            this.stack.queuedScopeChanges.push(doChange);
+        }
+    }
+
+    closeSubScopes() {
+        this.stack.target = this.scope.constructor;
+        while (!this.isActive) {
+            const ctx = this.stack.stack.pop();
+            if (!ctx) {
+                throw new Error('no scope in stack');
+            }
+            ctx.exitThis();
+        }
+        this.stack.target = undefined;
+    }
+
+    private logStack() {
+        if (SCOPE_CONTEXT.log) {
+            console.debug('%c' + this.stack.stack.map(c => c.scope.constructor.name).join(' -> '), 'color:yellow');
+        }
+    }
+
+    getStackClasses(): Scope[] {
+        return this.stack.stack.map(context => context.scope.constructor);
+    }
+
+    addScopeSignal<T>(signal: Signal<T>, callback: SignalCallback<T>, params?: AddScopeSignalOptions) {
+        const signalBinding = new ScopeSignalBinding(signal.add(callback, params?.context), params);
+        this.signalBindings.push(signalBinding);
+    }
+
+    disableKeepAliveSignals() {
+        this.muteKeepAliveSignals = true;
+        this.updateSignalBindings();
+    }
+
+    enableKeepAliveSignals() {
+        this.muteKeepAliveSignals = false;
+        this.updateSignalBindings();
+    }
+
+    private updateSignalBindings(muteKeepAlive = false) {
+        for (const binding of this.signalBindings) {
+            if (this.isActive) {
+                binding.activate();
+            } else if (muteKeepAlive) {
+                binding.deactivate();
+            } else if (binding.keepAlive === true) {
+                binding.activate();
+            } else if (!!(binding.keepAlive)) {
+                // is array of scopes
+                // OPT: cache active context?
+                if (binding.keepAlive.indexOf(this.activeContext.scope.constructor) != -1) {
+                    binding.activate();
+                } else {
+                    binding.deactivate();
+                }
+            } else {
+                binding.deactivate();
+            }
+        }
+        muteKeepAlive = muteKeepAlive || this.muteKeepAliveSignals;
+        this.parent?.updateSignalBindings(muteKeepAlive);
+    }
+
+    private detachSignalBindings() {
+        for (const signalBinding of this.signalBindings) {
+            signalBinding.detach();
+        }
+    }
+
+    private mapScopeSignals() {
+        const handlers = scopeSignalHandlers.get(this.scope.constructor);
+        if (!handlers) return;
+
+        for (const [field, id, options] of handlers) {
+            const signal = this.injector.getSignal(id);
+            const callback = (<any>this.scope) [field];
+            this.addScopeSignal(signal, callback, {...options, context: this.scope});
+        }
+    }
+
+    private mapServiceSignals(scopeService: Object) {
+        const handlers = signalHandlers.get(scopeService.constructor);
+        if (!handlers) return;
+
+        for (const [field, id] of handlers) {
+            const signal = this.injector.getSignal(id);
+            const signalBinding = signal.add((<any>scopeService) [field], scopeService);
+            this.serviceBindings.push(signalBinding);
+        }
+    }
+
+    private detachServiceBindings() {
+        for (const binding of this.serviceBindings) {
+            binding.detach();
+        }
+        this.serviceBindings = [];
+    }
+
+    private exitThis() {
+
+        // TODO: BUG: when there is a scope change within another scope change there is some confusion about the call order
+        if (!this.parent) {
+            throw new Error('can\'t exit root scope?!');
+        }
+
+        this.logStack();
+        this.detachSignalBindings();
+        this.detachServiceBindings();
+        this.scope.onDeactivate?.();
+        this.onDeactivate.dispatch(this);
+
+        this.scope.onExit?.();
+        this.onExit.dispatch(this);
+
+        this.injector._dispose();
+
+        this.parent.updateSignalBindings();
+        this.parent.scope.onSubReturn?.();
+        this.onSubReturn.dispatch(this);
+        this.parent.scope.onActivate?.();
+        this.parent.onActivate.dispatch(this);
+        this.closed = true;
+
+        this.onEnter.detachAll();
+        this.onExit.detachAll();
+        this.onSubReturn.detachAll();
+        this.onSubExit.detachAll();
+        this.onActivate.detachAll();
+        this.onDeactivate.detachAll();
+
+    }
+}