neo.mjs 5.13.10 → 5.14.1

package/src/util/Logger.mjs

@@ -6,38 +6,6 @@ import Base from '../core/Base.mjs';
  * @singleton
  */
 class Logger extends Base {
-    /**
-     * Colors
-     * @property {Object} colors
-     */
-    logColors = {
-        error: 'indianred',
-        info : '#acacac',
-        log  : '#448888',
-        warn : '#6d6d00'
-    }
-    /**
-     * Character
-     * @property {Object} logChar
-     */
-    logChars = {
-        error: 'E',
-        info : 'I',
-        log  : 'L',
-        warn : 'W'
-    }
-    /**
-     * LogLevels
-     * @property {String[]} logLevels
-     */
-    logLevels = ['info', 'log', 'warn', 'error']
-
-    /**
-     * Timeout
-     * @property {Number} timeToStart in ms
-     */
-    timeToStartComponentLogger = 1500
-
     static config = {
         /**
          * @member {String} className='Neo.util.Logger'
@@ -50,7 +18,7 @@ class Logger extends Base {
          *
          *     Neo.util.Logger.enableLogsInProduction = true;
          *
-         * @member {boolean} enableLogsInProduction=true
+         * @member {Boolean} enableLogsInProduction=true
          */
         enableLogsInProduction: false,
         /**
@@ -59,9 +27,9 @@ class Logger extends Base {
          *
          *      Neo.util.Logger.enableComponentLogger = true;
          *
-         * @member {boolean} enableComponentLogger_=true
+         * @member {Boolean} enableComponentLogger=true
          */
-        enableComponentLogger_: true,
+        enableComponentLogger: true,
         /**
          * Set the minimum level, which you want to output.
          * Change this at any time using a value of logLevels: ['info', 'log', 'warn', 'error']
@@ -73,19 +41,43 @@ class Logger extends Base {
          */
         level_: 'info',
         /**
-         * @member {boolean} enableLogs=true
+         * @member {Boolean} enableLogs=true
          * @protected
          */
         singleton: true
     }
 
+    /**
+     * @member {Object} logChar
+     */
+    logChars  = {
+        error: 'E',
+        info : 'I',
+        log  : 'L',
+        warn : 'W'
+    }
+    /**
+     * @member {Object} colors
+     */
+    logColors = {
+        error: 'indianred',
+        info : '#acacac',
+        log  : '#448888',
+        warn : '#6d6d00'
+    }
+    /**
+     * LogLevels
+     * @member {String[]} logLevels
+     */
+    logLevels = ['info', 'log', 'warn', 'error']
+
     /**
      * @param config
      */
     construct(config) {
         super.construct(config);
 
-        const me = this;
+        let me = this;
 
         // aliases
         Neo.applyFromNs(Neo, me, {
@@ -98,188 +90,185 @@ class Logger extends Base {
 
         setTimeout(() => {
             if (!me.enableLogsInProduction && Neo.config.environment === 'dist/production') {
-                me.write = Neo.emptyFn;
+                me.write = Neo.emptyFn
             }
-        }, 50);
+        }, 50)
     }
 
     /**
      * Ctrl-Right Click will show the current component
-     * @param {Boolean} value
-     * @param {Boolean} oldValue
+     * @param {Neo.component.Base} view
      */
-    afterSetEnableComponentLogger(value, oldValue) {
-        setTimeout(() => {
-            if (value) {
-                if (Neo.workerId !== 'app' || Neo.config.environment === 'dist/production') return;
-
-                const viewport = Neo.getComponent('neo-viewport-1') || Neo.getComponent('neo-configuration-viewport-1');
-                if (!viewport) {
-                    console.warn('[LOGGER] could not find viewport.');
-                    return;
-                }
-
-                viewport.addDomListeners({
-                    contextmenu: (data) => {
-                        if (data.ctrlKey) {
-                            let isGroupSet = false;
-
-                            data.path.forEach((item) => {
-                                const component = Neo.getComponent(item.id);
-
-                                if (component) {
-                                    if (!isGroupSet) {
-                                        isGroupSet = true;
-                                        console.group(item.id);
-                                    }
-                                    console.log(component);
-                                }
-                            });
-
-                            if (isGroupSet) {
-                                console.groupEnd();
-                            }
-                        }
-                    }
-                });
-            }
-        }, this.timeToStartComponentLogger);
+    addContextMenuListener(view) {
+        view.addDomListeners({
+            contextmenu: this.onContextMenu,
+            scope      : this
+        })
     }
 
     /**
      * Set level to number based on position in logLevels
      * @param {String} value
      * @param {String|Number} oldValue
-     * @returns {number}
+     * @returns {Number}
      */
     beforeSetLevel(value, oldValue) {
-        return this.logLevels.indexOf(value);
+        return this.logLevels.indexOf(value)
     }
 
     /**
-     * @param value
+     * @param {String} value
      */
     error(value) {
-        throw new Error(value);
+        throw new Error(value)
     }
 
     /**
-     * @param args
+     * internal helper to catch caller
+     * no known native way in modern JS to know what file that triggered the current method
+     * therefore we use Error, we can get the caller file from the stack trace string.
+     * @protected
+     * @returns {String}
      */
-    info(...args) {
-        args = this.resolveArgs(...args);
-        this.write(args, 'info');
-    }
+    getCaller() {
+        let caller_path = undefined,
+            err         = new Error(),
+            stack_lines = err.stack.split('\n'),
+            found_this  = false,
+            i, line;
+
+        for (i in stack_lines) {
+            line = stack_lines[i];
+
+            if (!found_this && /Logger\.mjs/.test(line)) {
+                found_this = true
+            } else if (found_this) {
+                if (!/Logger\.mjs/.test(line)) {
+                    // remove the closing )
+                    line        = line.replace(')', '');
+                    // get the part after the last /
+                    caller_path = line.match(/([^\/]+)$/)[1].match(/([^ ]+)$/)[1];
+
+                    break;
+                }
+            }
+        }
 
-    /**
-     * @param args
-     */
-    log(...args) {
-        args = this.resolveArgs(...args);
-        this.write(args, 'log');
+        return caller_path
     }
 
     /**
      * @param args
      */
-    logError(...args) {
+    info(...args) {
         args = this.resolveArgs(...args);
-        this.write(args, 'error');
+        this.write(args, 'info')
     }
 
     /**
      * @param args
      */
-    warn(...args) {
+    log(...args) {
         args = this.resolveArgs(...args);
-        this.write(args, 'warn');
+        this.write(args, 'log')
     }
 
     /**
-     * Output method
      * @param args
-     * @param {String} level
-     * @protected
      */
-    write(args, level) {
-        const me = this;
-        if (me.beforeSetLevel(level) < me.level) return;
-
-        const logColor = me.logColors[level],
-              logChar  = me.logChars[level],
-              bg       = `background-color:${logColor}; color: white; font-weight: 900;`,
-              color    = `color:${logColor};`,
-              msg      = `[${me.getCaller()}] ${args.msg}`;
-
-        if (args.data) {
-            console.groupCollapsed(`%c ${logChar} %c ${msg}`, bg, color)
-            console.log(args.data);
-            console.groupEnd();
-        } else {
-            console.log(`%c ${logChar} %c ${msg}`, bg, color)
-        }
+    logError(...args) {
+        args = this.resolveArgs(...args);
+        this.write(args, 'error')
     }
 
     /**
-     * HELPER TO CATCH CALLER
-     * no known native way in modern JS to know what file that triggered the current method
-     * therefore we use Error, we can get the caller file from the stack trace string.
+     * @param {Object} data
      */
-    getCaller() {
-        let caller_path = undefined;
-
-        try {
-            throw Error();
-
-        } catch (err) {
-            const stack_lines = err.stack.split('\n');
-            let found_this = false;
-
-            for (let i in stack_lines) {
-                let line = stack_lines[i];
-
-                if (!found_this && /Logger\.mjs/.test(line)) {
-                    found_this = true
-
-                } else if (found_this) {
-                    if (!/Logger\.mjs/.test(line)) {
-                        // remove the closing )
-                        line = line.replace(')', '');
-                        // get the part after the last /
-                        caller_path = line.match(/([^\/]+)$/)[1].match(/([^ ]+)$/)[1];
-
-                        break;
+    onContextMenu(data) {
+        if (
+            data.ctrlKey
+            && this.enableComponentLogger
+            && !(Neo.config.env === 'dist/production' && this.enableLogsInProduction)
+        ) {
+            let isGroupSet = false,
+                component;
+
+            data.path.forEach(item => {
+                component = Neo.getComponent(item.id);
+
+                if (component) {
+                    if (!isGroupSet) {
+                        isGroupSet = true;
+                        console.group(item.id)
                     }
-                }
 
-            }
+                    console.log(component)
+                }
+            });
 
-            return caller_path
+            isGroupSet && console.groupEnd()
         }
     }
 
     /**
-     * HELPER FOR ARGS
+     * Internal helper for args
      * @param {Array} args
-     * @return {Object}
+     * @returns {Object}
+     * @protected
      */
     resolveArgs(...args) {
         const identifier = args[0];
-        let argsObject = {};
+        let argsObject   = {};
 
         if (args.length === 1) {
             if (Neo.isString(identifier)) {
-                argsObject.msg = args[0];
+                argsObject.msg = args[0]
             } else if (Neo.isObject(identifier)) {
-                argsObject = identifier;
+                argsObject = identifier
             }
         } else if (args.length === 2) {
-            argsObject.msg = args[0];
-            argsObject.data = args[1];
+            argsObject.msg  = args[0];
+            argsObject.data = args[1]
         }
 
         return argsObject
     }
+
+    /**
+     * @param args
+     */
+    warn(...args) {
+        args = this.resolveArgs(...args);
+        this.write(args, 'warn')
+    }
+
+    /**
+     * Output method
+     * @param {Object} args
+     * @param {String} level
+     * @protected
+     */
+    write(args, level) {
+        let me = this;
+
+        if (me.beforeSetLevel(level) < me.level) {
+            return
+        }
+
+        let logColor = me.logColors[level],
+            logChar  = me.logChars[level],
+            bg       = `background-color:${logColor}; color: white; font-weight: 900;`,
+            color    = `color:${logColor};`,
+            msg      = `[${me.getCaller()}] ${args.msg}`;
+
+        if (args.data) {
+            console.groupCollapsed(`%c ${logChar} %c ${msg}`, bg, color)
+            console.log(args.data);
+            console.groupEnd()
+        } else {
+            console.log(`%c ${logChar} %c ${msg}`, bg, color)
+        }
+    }
 }
 
 let instance = Neo.applyClassConfig(Logger);