mani-game-engine 1.0.0-pre.34 → 1.0.0-pre.35

package/src/scope/scopeContext.ts

@@ -1,320 +1,322 @@
-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: Function[] = [];
-    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,
-}) => 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;
-    }
-
-    // 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
-     */
-    enterScope(scopeClass: Class, mapping?: ScopeMapping): ScopeContext | undefined {
-        let newContext;
-        const doChange = () => {
-
-            this.activeContext.scope.onSubExit?.();
-            this.activeContext.scope.onDeactivate?.();
-
-            newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext);
-
-            this.logStack();
-            const nextChange = this.stack.queuedScopeChanges.shift();
-            if (nextChange) {
-                nextChange();
-            } else {
-                this.stack.ongoingChange = false;
-            }
-        };
-        // TODO: this queued changes arent somewhat experimental
-        if (!this.stack.ongoingChange) {
-            this.stack.ongoingChange = true;
-            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
-     */
-    exitScope(target?: Scope) {
-        const doChange = () => {
-            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) {
-                nextChange();
-            } else {
-                this.stack.ongoingChange = false;
-            }
-
-        };
-        if (!this.stack.ongoingChange) {
-            this.stack.ongoingChange = true;
-            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.scope.onExit?.();
-        this.parent.updateSignalBindings();
-        this.parent.scope.onSubReturn?.();
-        this.parent.scope.onActivate?.();
-        this.closed = true;
-    }
-}
+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: Function[] = [];
+    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,
+}) => 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);
+        }
+
+        // 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);
+
+        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;
+    }
+
+    // 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
+     */
+    enterScope(scopeClass: Class, mapping?: ScopeMapping): ScopeContext | undefined {
+        let newContext;
+        const doChange = () => {
+
+            this.activeContext.scope.onSubExit?.();
+            this.activeContext.scope.onDeactivate?.();
+
+            newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext);
+
+            this.logStack();
+            const nextChange = this.stack.queuedScopeChanges.shift();
+            if (nextChange) {
+                nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+        };
+        // TODO: this queued changes arent somewhat experimental
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            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
+     */
+    exitScope(target?: Scope) {
+        const doChange = () => {
+            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) {
+                nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+
+        };
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            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.scope.onExit?.();
+        this.parent.updateSignalBindings();
+        this.parent.scope.onSubReturn?.();
+        this.parent.scope.onActivate?.();
+        this.closed = true;
+    }
+}