@reliverse/relinka 1.1.7 → 1.1.8

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

@@ -1,338 +1,280 @@
-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];
+import { defu } from "defu";
+import { LogTypes } from "../../utils/constants.js";
+import { isLogObj } from "../../utils/log.js";
 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 || [].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);
+    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
         }
-        if (this.options.mockFn) {
-            this.mockTypes();
-        }
-        
-        this._lastLog = {};
+      }
+    );
+    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
+      );
     }
-    
-    get level() {
-        return this.options.level;
+    if (this.options.mockFn) {
+      this.mockTypes();
     }
-    
+    this._lastLog = {};
+  }
+    get 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 Error('prompt is not supported!');
-        }
-        
-        return this.options.prompt(message, opts);
+    if (!this.options.prompt) {
+      throw new Error("prompt is not supported!");
     }
-    
+    return this.options.prompt(message, opts);
+  }
     create(options) {
-        const instance = new Relinka({
-            ...this.options,
-            ...options,
-        });
-        
-        if (this._mockFn) {
-            instance.mockTypes(this._mockFn);
-        }
-        
-        return instance;
+    const instance = new Relinka({
+      ...this.options,
+      ...options
+    });
+    if (this._mockFn) {
+      instance.mockTypes(this._mockFn);
     }
-    
+    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);
-        }
-        
-        return this;
+    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;
+  }
     setReporters(reporters) {
-        this.options.reporters = maybeArray(reporters);
-        return this;
-    }
-    
-    wrapAll() {
-        this.wrapConsole();
-        this.wrapStd();
-    }
-    
-    restoreAll() {
-        this.restoreConsole();
-        this.restoreStd();
-    }
-    
+    this.options.reporters = Array.isArray(reporters) ? reporters : [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');
+    this._wrapStream(this.options.stdout, "log");
+    this._wrapStream(this.options.stderr, "log");
+  }
+  _wrapStream(stream, type) {
+    if (!stream) {
+      return;
     }
-    
-    _wrapStream(stream, type) {
-        if (!stream) {
-            return;
-        }
-        
-        if (!stream.__write) {
-            stream.__write = stream.write;
-        }
-        
-        stream.write = (data) => {
-            this[type].raw(String(data).trim());
-        };
+    if (!stream.__write) {
+      stream.__write = stream.write;
     }
-    
+    stream.write = (data) => {
+      this[type].raw(String(data).trim());
+    };
+  }
     restoreStd() {
-        this._restoreStream(this.options.stdout);
-        this._restoreStream(this.options.stderr);
+    this._restoreStream(this.options.stdout);
+    this._restoreStream(this.options.stderr);
+  }
+  _restoreStream(stream) {
+    if (!stream) {
+      return;
     }
-    
-    _restoreStream(stream) {
-        if (!stream) {
-            return;
-        }
-        
-        if (stream.__write) {
-            stream.write = stream.__write;
-            delete stream.__write;
-        }
+    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 (!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];
-        }
+    const _mockFn = mockFn || this.options.mockFn;
+    this._mockFn = _mockFn;
+    if (typeof _mockFn !== "function") {
+      return;
     }
-    
-    _wrapLogFn(defaults, isRaw) {
-        return (...args) => {
-            if (paused) {
-                queue.push([
-                    this,
-                    defaults,
-                    args,
-                    isRaw,
-                ]);
-                return;
-            }
-            
-            return this._logFn(defaults, args, isRaw);
-        };
+    for (const type in this.options.types) {
+      this[type] = _mockFn(type, this.options.types[type]) || this[type];
+      this[type].raw = this[type];
     }
-    
-    _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);
+  }
+  _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;
     }
-    
-    _log(logObj) {
-        for (const reporter of this.options.reporters) {
-            reporter.log(logObj, {
-                options: this.options,
-            });
-        }
+    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];
     }
-}function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
-    if (input === void 0) {
-        return defaultLevel;
+    if (logObj.message) {
+      logObj.args.unshift(logObj.message);
+      delete logObj.message;
     }
-    
-    if (isNumber(input)) {
-        return input;
+    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;
     }
-    
-    if (types[input] && types[input].level !== void 0) {
-        return types[input].level;
+    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 {
+      }
     }
-    
+    resolveLog(true);
+  }
+  _log(logObj) {
+    for (const reporter of this.options.reporters) {
+      reporter.log(logObj, {
+        options: this.options
+      });
+    }
+  }
+}
+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;
@@ -341,5 +283,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);
 }