Reducing amount of code in Observable and Logger

packages/dev/core/src/Misc/index.ts

@@ -11,6 +11,7 @@ export * from "./filesInput";
 export * from "./HighDynamicRange/index";
 export * from "./khronosTextureContainer";
 export * from "./observable";
+export * from "./observable.extensions";
 export * from "./performanceMonitor";
 export * from "./sceneOptimizer";
 export * from "./sceneSerializer";

packages/dev/core/src/Misc/logger.ts

@@ -31,6 +31,14 @@ export class Logger {
 
     private static _LogCache = "";
     private static _LogLimitOutputs: { [message: string]: { limit: number; current: number } } = {};
+    // levels according to the (binary) numbering.
+    private static _Levels = [
+        {},
+        { color: "white", logFunc: console.log, name: "Log" },
+        { color: "orange", logFunc: console.warn, name: "Warn" },
+        {},
+        { color: "red", logFunc: console.error, name: "Error" },
+    ];
 
     /**
      * Gets a value indicating the number of loading errors
@@ -55,23 +63,14 @@ export class Logger {
         return entry.current <= entry.limit;
     }
 
-    private static _GenerateLimitMessage(message: string, messageType: number): void {
+    private static _GenerateLimitMessage(message: string, level: number = 1): void {
         const entry = Logger._LogLimitOutputs[message];
         if (!entry || !Logger.MessageLimitReached) {
             return;
         }
+        const type = this._Levels[level];
         if (entry.current === entry.limit) {
-            switch (messageType) {
-                case 0:
-                    Logger.Log(Logger.MessageLimitReached.replace(/%LIMIT%/g, "" + entry.limit).replace(/%TYPE%/g, "log"));
-                    break;
-                case 1:
-                    Logger.Warn(Logger.MessageLimitReached.replace(/%LIMIT%/g, "" + entry.limit).replace(/%TYPE%/g, "warning"));
-                    break;
-                case 2:
-                    Logger.Error(Logger.MessageLimitReached.replace(/%LIMIT%/g, "" + entry.limit).replace(/%TYPE%/g, "error"));
-                    break;
-            }
+            Logger.Log(Logger.MessageLimitReached.replace(/%LIMIT%/g, "" + entry.limit).replace(/%TYPE%/g, type.name ?? ""));
         }
     }
 
@@ -94,71 +93,34 @@ export class Logger {
     private static _LogDisabled(message: string, limit?: number): void {
         // nothing to do
     }
-    private static _LogEnabled(message: string, limit?: number): void {
+    private static _LogEnabled(level: number = 1, message: string, limit?: number): void {
         if (limit !== undefined && !Logger._CheckLimit(message, limit)) {
             return;
         }
 
         const formattedMessage = Logger._FormatMessage(message);
-        console.log("BJS - " + formattedMessage);
+        const type = this._Levels[level];
+        type.logFunc && type.logFunc("BJS - " + formattedMessage);
 
-        const entry = "<div style='color:white'>" + formattedMessage + "</div><br>";
+        const entry = `<div style='color:${type.color}'>${formattedMessage}</div><br>`;
         Logger._AddLogEntry(entry);
-
-        Logger._GenerateLimitMessage(message, 0);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    private static _WarnDisabled(message: string, limit?: number): void {
-        // nothing to do
-    }
-    private static _WarnEnabled(message: string, limit?: number): void {
-        if (limit !== undefined && !Logger._CheckLimit(message, limit)) {
-            return;
-        }
-
-        const formattedMessage = Logger._FormatMessage(message);
-        console.warn("BJS - " + formattedMessage);
-
-        const entry = "<div style='color:orange'>" + message + "</div><br>";
-        Logger._AddLogEntry(entry);
-
-        Logger._GenerateLimitMessage(message, 1);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    private static _ErrorDisabled(message: string, limit?: number): void {
-        // nothing to do
-    }
-    private static _ErrorEnabled(message: string, limit?: number): void {
-        if (limit !== undefined && !Logger._CheckLimit(message, limit)) {
-            return;
-        }
-
-        const formattedMessage = Logger._FormatMessage(message);
-        Logger.errorsCount++;
-        console.error("BJS - " + formattedMessage);
-
-        const entry = "<div style='color:red'>" + formattedMessage + "</div><br>";
-        Logger._AddLogEntry(entry);
-
-        Logger._GenerateLimitMessage(message, 2);
+        Logger._GenerateLimitMessage(message, level);
     }
 
     /**
      * Log a message to the console
      */
-    public static Log: (message: string, limit?: number) => void = Logger._LogEnabled;
+    public static Log: (message: string, limit?: number) => void = Logger._LogEnabled.bind(Logger, Logger.MessageLogLevel);
 
     /**
      * Write a warning message to the console
      */
-    public static Warn: (message: string, limit?: number) => void = Logger._WarnEnabled;
+    public static Warn: (message: string, limit?: number) => void = Logger._LogEnabled.bind(Logger, Logger.WarningLogLevel);
 
     /**
      * Write an error message to the console
      */
-    public static Error: (message: string, limit?: number) => void = Logger._ErrorEnabled;
+    public static Error: (message: string, limit?: number) => void = Logger._LogEnabled.bind(Logger, Logger.ErrorLogLevel);
 
     /**
      * Gets current log cache (list of logs)
@@ -180,22 +142,14 @@ export class Logger {
      * Sets the current log level (MessageLogLevel / WarningLogLevel / ErrorLogLevel)
      */
     public static set LogLevels(level: number) {
-        if ((level & Logger.MessageLogLevel) === Logger.MessageLogLevel) {
-            Logger.Log = Logger._LogEnabled;
-        } else {
-            Logger.Log = Logger._LogDisabled;
-        }
-
-        if ((level & Logger.WarningLogLevel) === Logger.WarningLogLevel) {
-            Logger.Warn = Logger._WarnEnabled;
-        } else {
-            Logger.Warn = Logger._WarnDisabled;
-        }
-
-        if ((level & Logger.ErrorLogLevel) === Logger.ErrorLogLevel) {
-            Logger.Error = Logger._ErrorEnabled;
-        } else {
-            Logger.Error = Logger._ErrorDisabled;
-        }
+        Logger.Log = Logger._LogDisabled;
+        Logger.Warn = Logger._LogDisabled;
+        Logger.Error = Logger._LogDisabled;
+        [Logger.MessageLogLevel, Logger.WarningLogLevel, Logger.ErrorLogLevel].forEach((l) => {
+            if ((level & l) === l) {
+                const type = this._Levels[l];
+                Logger[type.name as "Log" | "Warn" | "Error"] = Logger._LogEnabled.bind(Logger, l);
+            }
+        });
     }
 }

packages/dev/core/src/Misc/observable.extensions.ts

@@ -0,0 +1,116 @@
+import type { Nullable } from "../types";
+import type { Observer, EventState } from "./observable";
+import { Observable } from "./observable";
+
+/**
+ * Represent a list of observers registered to multiple Observables object.
+ */
+export class MultiObserver<T> {
+    private _observers: Nullable<Observer<T>[]>;
+    private _observables: Nullable<Observable<T>[]>;
+
+    /**
+     * Release associated resources
+     */
+    public dispose(): void {
+        if (this._observers && this._observables) {
+            for (let index = 0; index < this._observers.length; index++) {
+                this._observables[index].remove(this._observers[index]);
+            }
+        }
+
+        this._observers = null;
+        this._observables = null;
+    }
+
+    /**
+     * Raise a callback when one of the observable will notify
+     * @param observables defines a list of observables to watch
+     * @param callback defines the callback to call on notification
+     * @param mask defines the mask used to filter notifications
+     * @param scope defines the current scope used to restore the JS context
+     * @returns the new MultiObserver
+     */
+    public static Watch<T>(observables: Observable<T>[], callback: (eventData: T, eventState: EventState) => void, mask: number = -1, scope: any = null): MultiObserver<T> {
+        const result = new MultiObserver<T>();
+
+        result._observers = new Array<Observer<T>>();
+        result._observables = observables;
+
+        for (const observable of observables) {
+            const observer = observable.add(callback, mask, false, scope);
+            if (observer) {
+                result._observers.push(observer);
+            }
+        }
+
+        return result;
+    }
+}
+
+declare module "./observable" {
+    export interface Observable<T> {
+        /**
+         * Calling this will execute each callback, expecting it to be a promise or return a value.
+         * If at any point in the chain one function fails, the promise will fail and the execution will not continue.
+         * This is useful when a chain of events (sometimes async events) is needed to initialize a certain object
+         * and it is crucial that all callbacks will be executed.
+         * The order of the callbacks is kept, callbacks are not executed parallel.
+         *
+         * @param eventData The data to be sent to each callback
+         * @param mask is used to filter observers defaults to -1
+         * @param target defines the callback target (see EventState)
+         * @param currentTarget defines he current object in the bubbling phase
+         * @param userInfo defines any user info to send to observers
+         * @returns {Promise<T>} will return a Promise than resolves when all callbacks executed successfully.
+         */
+        notifyObserversWithPromise(eventData: T, mask?: number, target?: any, currentTarget?: any, userInfo?: any): Promise<T>;
+    }
+}
+
+Observable.prototype.notifyObserversWithPromise = async function <T>(eventData: T, mask: number = -1, target?: any, currentTarget?: any, userInfo?: any): Promise<T> {
+    // create an empty promise
+    let p: Promise<any> = Promise.resolve(eventData);
+
+    // no observers? return this promise.
+    if (!this.observers.length) {
+        return p;
+    }
+
+    const state = this._eventState;
+    state.mask = mask;
+    state.target = target;
+    state.currentTarget = currentTarget;
+    state.skipNextObservers = false;
+    state.userInfo = userInfo;
+
+    // execute one callback after another (not using Promise.all, the order is important)
+    this.observers.forEach((obs) => {
+        if (state.skipNextObservers) {
+            return;
+        }
+        if (obs._willBeUnregistered) {
+            return;
+        }
+        if (obs.mask & mask) {
+            if (obs.scope) {
+                p = p.then((lastReturnedValue) => {
+                    state.lastReturnValue = lastReturnedValue;
+                    return obs.callback.apply(obs.scope, [eventData, state]);
+                });
+            } else {
+                p = p.then((lastReturnedValue) => {
+                    state.lastReturnValue = lastReturnedValue;
+                    return obs.callback(eventData, state);
+                });
+            }
+            if (obs.unregisterOnNextCall) {
+                this._deferUnregister(obs);
+            }
+        }
+    });
+
+    // return the eventData
+    await p;
+    return eventData;
+};