@reliverse/relinka 1.1.5 → 1.1.6

package/dist-npm/components/prompts/relinka.js

@@ -1,280 +1,338 @@
-import { defu } from "defu";
-import { LogTypes } from "../../utils/constants.js";
-import { isLogObj } from "../../utils/log.js";
+import {defu} from 'defu';
+import {LogTypes} from '../../utils/constants.js';
+import {isLogObj} from '../../utils/log.js';
+
+const {isArray} = Array;
+const isNumber = (a) => typeof a === 'number';
+const isString = (a) => typeof a === 'string';
+const isFn = (a) => typeof a === 'function';
+const maybeArray = (a) => isArray(a) ? a : [a];
 let paused = false;
 const queue = [];
+
 export class Relinka {
-  options;
-  _lastLog;
-  _mockFn;
+    options;
+    _lastLog;
+    _mockFn;
     constructor(options = {}) {
-    const types = options.types || LogTypes;
-    this.options = defu(
-      {
-        ...options,
-        defaults: { ...options.defaults },
-        level: _normalizeLogLevel(options.level, types),
-        reporters: [...options.reporters || []]
-      },
-      {
-        types: LogTypes,
-        throttle: 1e3,
-        throttleMin: 5,
-        formatOptions: {
-          date: true,
-          colors: false,
-          compact: true
+        const types = options.types || LogTypes;
+        
+        this.options = defu({
+            ...options,
+            defaults: {...options.defaults},
+            level: _normalizeLogLevel(options.level, types),
+            reporters: options.reporters || [].slice(),
+        }, {
+            types: LogTypes,
+            throttle: 1e3,
+            throttleMin: 5,
+            formatOptions: {
+                date: true,
+                colors: false,
+                compact: true,
+            },
+        });
+        for (const type in types) {
+            const defaults = {
+                type,
+                ...this.options.defaults,
+                ...types[type],
+            };
+            
+            this[type] = this._wrapLogFn(defaults);
+            this[type].raw = this._wrapLogFn(defaults, true);
         }
-      }
-    );
-    for (const type in types) {
-      const defaults = {
-        type,
-        ...this.options.defaults,
-        ...types[type]
-      };
-      this[type] = this._wrapLogFn(defaults);
-      this[type].raw = this._wrapLogFn(
-        defaults,
-        true
-      );
-    }
-    if (this.options.mockFn) {
-      this.mockTypes();
+        if (this.options.mockFn) {
+            this.mockTypes();
+        }
+        
+        this._lastLog = {};
     }
-    this._lastLog = {};
-  }
+    
     get level() {
-    return this.options.level;
-  }
+        return this.options.level;
+    }
+    
     set level(level) {
-    this.options.level = _normalizeLogLevel(
-      level,
-      this.options.types,
-      this.options.level
-    );
-  }
+        this.options.level = _normalizeLogLevel(level, this.options.types, this.options.level);
+    }
+    
     prompt(message, opts) {
-    if (!this.options.prompt) {
-      throw new Error("prompt is not supported!");
+        if (!this.options.prompt) {
+            throw Error('prompt is not supported!');
+        }
+        
+        return this.options.prompt(message, opts);
     }
-    return this.options.prompt(message, opts);
-  }
+    
     create(options) {
-    const instance = new Relinka({
-      ...this.options,
-      ...options
-    });
-    if (this._mockFn) {
-      instance.mockTypes(this._mockFn);
+        const instance = new Relinka({
+            ...this.options,
+            ...options,
+        });
+        
+        if (this._mockFn) {
+            instance.mockTypes(this._mockFn);
+        }
+        
+        return instance;
     }
-    return instance;
-  }
+    
     withDefaults(defaults) {
-    return this.create({
-      ...this.options,
-      defaults: {
-        ...this.options.defaults,
-        ...defaults
-      }
-    });
-  }
+        return this.create({
+            ...this.options,
+            defaults: {
+                ...this.options.defaults,
+                ...defaults,
+            },
+        });
+    }
+    
     withTag(tag) {
-    return this.withDefaults({
-      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
-    });
-  }
+        return this.withDefaults({
+            tag: this.options.defaults.tag ? this.options.defaults.tag + ':' + tag : tag,
+        });
+    }
+    
     addReporter(reporter) {
-    this.options.reporters.push(reporter);
-    return this;
-  }
+        this.options.reporters.push(reporter);
+        return this;
+    }
+    
     removeReporter(reporter) {
-    if (reporter) {
-      const i = this.options.reporters.indexOf(reporter);
-      if (i >= 0) {
-        return this.options.reporters.splice(i, 1);
-      }
-    } else {
-      this.options.reporters.splice(0);
+        if (reporter) {
+            const i = this.options.reporters.indexOf(reporter);
+            
+            if (i >= 0) {
+                return this.options.reporters.splice(i, 1);
+            }
+        } else {
+            this.options.reporters.splice(0);
+        }
+        
+        return this;
     }
-    return this;
-  }
+    
     setReporters(reporters) {
-    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
-    return this;
-  }
-  wrapAll() {
-    this.wrapConsole();
-    this.wrapStd();
-  }
-  restoreAll() {
-    this.restoreConsole();
-    this.restoreStd();
-  }
+        this.options.reporters = maybeArray(reporters);
+        return this;
+    }
+    
+    wrapAll() {
+        this.wrapConsole();
+        this.wrapStd();
+    }
+    
+    restoreAll() {
+        this.restoreConsole();
+        this.restoreStd();
+    }
+    
     wrapConsole() {
-    for (const type in this.options.types) {
-      if (!console["__" + type]) {
-        console["__" + type] = console[type];
-      }
-      console[type] = this[type].raw;
+        for (const type in this.options.types) {
+            if (!console[`__${type}`]) {
+                console[`__${type}`] = console[type];
+            }
+            
+            console[type] = this[type].raw;
+        }
     }
-  }
+    
     restoreConsole() {
-    for (const type in this.options.types) {
-      if (console["__" + type]) {
-        console[type] = console["__" + type];
-        delete console["__" + type];
-      }
+        for (const type in this.options.types) {
+            if (console[`__${type}`]) {
+                console[type] = console[`__${type}`];
+                delete console[`__${type}`];
+            }
+        }
     }
-  }
+    
     wrapStd() {
-    this._wrapStream(this.options.stdout, "log");
-    this._wrapStream(this.options.stderr, "log");
-  }
-  _wrapStream(stream, type) {
-    if (!stream) {
-      return;
+        this._wrapStream(this.options.stdout, 'log');
+        this._wrapStream(this.options.stderr, 'log');
     }
-    if (!stream.__write) {
-      stream.__write = stream.write;
+    
+    _wrapStream(stream, type) {
+        if (!stream) {
+            return;
+        }
+        
+        if (!stream.__write) {
+            stream.__write = stream.write;
+        }
+        
+        stream.write = (data) => {
+            this[type].raw(String(data).trim());
+        };
     }
-    stream.write = (data) => {
-      this[type].raw(String(data).trim());
-    };
-  }
+    
     restoreStd() {
-    this._restoreStream(this.options.stdout);
-    this._restoreStream(this.options.stderr);
-  }
-  _restoreStream(stream) {
-    if (!stream) {
-      return;
+        this._restoreStream(this.options.stdout);
+        this._restoreStream(this.options.stderr);
     }
-    if (stream.__write) {
-      stream.write = stream.__write;
-      delete stream.__write;
+    
+    _restoreStream(stream) {
+        if (!stream) {
+            return;
+        }
+        
+        if (stream.__write) {
+            stream.write = stream.__write;
+            delete stream.__write;
+        }
     }
-  }
+    
     pauseLogs() {
-    paused = true;
-  }
+        paused = true;
+    }
+    
     resumeLogs() {
-    paused = false;
-    const _queue = queue.splice(0);
-    for (const item of _queue) {
-      item[0]._logFn(item[1], item[2]);
+        paused = false;
+        const _queue = queue.splice(0);
+        
+        for (const item of _queue) {
+            item[0]._logFn(item[1], item[2]);
+        }
     }
-  }
+    
     mockTypes(mockFn) {
-    const _mockFn = mockFn || this.options.mockFn;
-    this._mockFn = _mockFn;
-    if (typeof _mockFn !== "function") {
-      return;
-    }
-    for (const type in this.options.types) {
-      this[type] = _mockFn(type, this.options.types[type]) || this[type];
-      this[type].raw = this[type];
+        const _mockFn = mockFn || this.options.mockFn;
+        
+        this._mockFn = _mockFn;
+        if (!isFn(_mockFn)) {
+            return;
+        }
+        
+        for (const type in this.options.types) {
+            this[type] = _mockFn(type, this.options.types[type]) || this[type];
+            this[type].raw = this[type];
+        }
     }
-  }
-  _wrapLogFn(defaults, isRaw) {
-    return (...args) => {
-      if (paused) {
-        queue.push([this, defaults, args, isRaw]);
-        return;
-      }
-      return this._logFn(defaults, args, isRaw);
-    };
-  }
-  _logFn(defaults, args, isRaw) {
-    if ((defaults.level || 0) > this.level) {
-      return false;
+    
+    _wrapLogFn(defaults, isRaw) {
+        return (...args) => {
+            if (paused) {
+                queue.push([
+                    this,
+                    defaults,
+                    args,
+                    isRaw,
+                ]);
+                return;
+            }
+            
+            return this._logFn(defaults, args, isRaw);
+        };
     }
-    const logObj = {
-      date:  new Date(),
-      args: [],
-      ...defaults,
-      level: _normalizeLogLevel(defaults.level, this.options.types)
-    };
-    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
-      Object.assign(logObj, args[0]);
-    } else {
-      logObj.args = [...args];
+    
+    _logFn(defaults, args, isRaw) {
+        if (this.level < (defaults.level || 0)) {
+            return false;
+        }
+        
+        const logObj = {
+            date: new Date(),
+            args: [],
+            ...defaults,
+            level: _normalizeLogLevel(defaults.level, this.options.types),
+        };
+        
+        if (!isRaw && args.length === 1 && isLogObj(args[0])) {
+            Object.assign(logObj, args[0]);
+        } else {
+            logObj.args = args.slice();
+        }
+        
+        if (logObj.message) {
+            logObj.args.unshift(logObj.message);
+            delete logObj.message;
+        }
+        
+        if (logObj.additional) {
+            if (!Array.isArray(logObj.additional)) {
+                logObj.additional = logObj.additional.split('\n');
+            }
+            
+            logObj.args.push('\n' + logObj.additional.join('\n'));
+            delete logObj.additional;
+        }
+        
+        logObj.type = isString(logObj.type) ? logObj.type.toLowerCase() : 'log';
+        if (!isString(logObj.tag))
+            logObj.tag = '';
+        
+        const resolveLog = (newLog = false) => {
+            const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
+            
+            if (this._lastLog.object && repeated > 0) {
+                const args2 = this._lastLog.object.args.slice();
+                
+                if (repeated > 1) {
+                    args2.push(`(repeated ${repeated} times)`);
+                }
+                
+                this._log({                    ...this._lastLog.object,
+args: args2});
+                this._lastLog.count = 1;
+            }
+            
+            if (newLog) {
+                this._lastLog.object = logObj;
+                this._log(logObj);
+            }
+        };
+        
+        clearTimeout(this._lastLog.timeout);
+        const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
+        
+        this._lastLog.time = logObj.date;
+        if (diffTime < this.options.throttle) {
+            try {
+                const serializedLog = JSON.stringify([
+                    logObj.type,
+                    logObj.tag,
+                    logObj.args,
+                ]);
+                
+                const isSameLog = this._lastLog.serialized === serializedLog;
+                
+                this._lastLog.serialized = serializedLog;
+                if (isSameLog) {
+                    this._lastLog.count = (this._lastLog.count || 0) + 1;
+                    if (this._lastLog.count > this.options.throttleMin) {
+                        this._lastLog.timeout = setTimeout(resolveLog, this.options.throttle);
+                        return;
+                    }
+                }
+            } catch {}
+        }
+        
+        resolveLog(true);
     }
-    if (logObj.message) {
-      logObj.args.unshift(logObj.message);
-      delete logObj.message;
+    
+    _log(logObj) {
+        for (const reporter of this.options.reporters) {
+            reporter.log(logObj, {
+                options: this.options,
+            });
+        }
     }
-    if (logObj.additional) {
-      if (!Array.isArray(logObj.additional)) {
-        logObj.additional = logObj.additional.split("\n");
-      }
-      logObj.args.push("\n" + logObj.additional.join("\n"));
-      delete logObj.additional;
+}function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
+    if (input === void 0) {
+        return defaultLevel;
     }
-    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
-    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
-    const resolveLog = (newLog = false) => {
-      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
-      if (this._lastLog.object && repeated > 0) {
-        const args2 = [...this._lastLog.object.args];
-        if (repeated > 1) {
-          args2.push(`(repeated ${repeated} times)`);
-        }
-        this._log({ ...this._lastLog.object, args: args2 });
-        this._lastLog.count = 1;
-      }
-      if (newLog) {
-        this._lastLog.object = logObj;
-        this._log(logObj);
-      }
-    };
-    clearTimeout(this._lastLog.timeout);
-    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
-    this._lastLog.time = logObj.date;
-    if (diffTime < this.options.throttle) {
-      try {
-        const serializedLog = JSON.stringify([
-          logObj.type,
-          logObj.tag,
-          logObj.args
-        ]);
-        const isSameLog = this._lastLog.serialized === serializedLog;
-        this._lastLog.serialized = serializedLog;
-        if (isSameLog) {
-          this._lastLog.count = (this._lastLog.count || 0) + 1;
-          if (this._lastLog.count > this.options.throttleMin) {
-            this._lastLog.timeout = setTimeout(
-              resolveLog,
-              this.options.throttle
-            );
-            return;
-          }
-        }
-      } catch {
-      }
+    
+    if (isNumber(input)) {
+        return input;
     }
-    resolveLog(true);
-  }
-  _log(logObj) {
-    for (const reporter of this.options.reporters) {
-      reporter.log(logObj, {
-        options: this.options
-      });
+    
+    if (types[input] && types[input].level !== void 0) {
+        return types[input].level;
     }
-  }
-}
-function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
-  if (input === void 0) {
+    
     return defaultLevel;
-  }
-  if (typeof input === "number") {
-    return input;
-  }
-  if (types[input] && types[input].level !== void 0) {
-    return types[input].level;
-  }
-  return defaultLevel;
 }
+
 Relinka.prototype.add = Relinka.prototype.addReporter;
 Relinka.prototype.remove = Relinka.prototype.removeReporter;
 Relinka.prototype.clear = Relinka.prototype.removeReporter;
@@ -283,5 +341,5 @@ Relinka.prototype.mock = Relinka.prototype.mockTypes;
 Relinka.prototype.pause = Relinka.prototype.pauseLogs;
 Relinka.prototype.resume = Relinka.prototype.resumeLogs;
 export function createRelinka(options = {}) {
-  return new Relinka(options);
+    return new Relinka(options);
 }