jet-logger 1.0.3 → 1.1.0

package/README.md

@@ -15,9 +15,9 @@ $ npm install --save jet-logger
 ```
 
 ### Guide
-The logger package's main export is the `Logger` class. Logger can used statically or as an instance 
+The logger package's main export is the `logger` object. Logger can used statically or as an instance 
 object with settings configured through a constructor. Variables passed through the constructor will
-take priority over environment variables.
+take priority over environment variables. Note that file writes happen asynchronously. 
 
 - The four environment variables are:
     - `JET_LOGGER_MODE`: can be `'CONSOLE'`(default), `'FILE'`, `'CUSTOM'`, and `'OFF'`.
@@ -27,18 +27,17 @@ take priority over environment variables.
 
 _logger_ has an export `LoggerModes` which is an enum that provides all the modes if you want to
 use them in code. I would recommend using `Console` for local development, `File` for remote development, 
-and `Custom` or `Off` for production. If you want to change the settings in code, you can do so via 
-the constructor or getters/setters.
+and `Custom` or `Off` for production. If you want to change the settings in code, you can do so via importing the `JetLogger` function and calling it with whatever options you want.
 <br>
 
-- There are 4 functions on Logger to print logs. Each has a static counterpart:
-    - `info` or `Info`: prints green.
-    - `imp` or `Imp`: prints magenta. 
-    - `warn` or `Warn`: prints yellow.
-    - `err` or `Err`: prints red.
+- There are 4 functions on Logger to print logs.
+    - `info`: prints green.
+    - `imp`: prints magenta. 
+    - `warn`: prints yellow.
+    - `err`: prints red.
 
 There is an optional second param to each method which is a `boolean`. If you pass `true` as the second 
-param, Logger will use node's `util` so that the full object gets printed. You should NOT normally 
+param, JetLogger will use node's `util` so that the full object gets printed. You should NOT normally 
 use this param, but it is especially useful when debugging errors so that you can print out the full 
 error object and observe the stack trace.<br>
 
@@ -47,7 +46,7 @@ Let's look at some sample code in an express route:
 ````typescript
 /* Some script that is run before the route script */
 
-// Apply logger settings (Note you could also use a tool "dotenv" to set env variables)
+// Apply logger settings (Note you could also using a tool "dotenv" to set env variables)
 // These must be set before logger is imported
 const logFilePath = path.join(__dirname, '../sampleProject.log');
 process.env.JET_LOGGER_MODE = LoggerModes.File; // Can also be Console, Custom, or Off
@@ -58,25 +57,12 @@ process.env.JET_LOGGER_FILEPATH = logFilePath;
 
 import { OK } from 'http-status-codes';
 import { Router, Request, Response } from 'express';
-import Logger from 'jet-logger';
+import logger from 'jet-logger';
 
 const router = Router();
 
 
-router.get('api/users', async (req: Request, res: Reponse) => {
-    Logger.Info(req.params.msg);
-    Logger.Imp(req.params.msg);
-    Logger.Warn(req.params.msg);
-    Logger.Err(req.params.msg);
-    Logger.Err(new Error('printing out an error'));
-    Logger.Err(new Error('printing out an error full'), true); // <-- print the full Error object
-    return res.status(OK).json({
-        message: 'static_console_mode',
-    });
-});
-
 router.get('api/users/alt', async (req: Request, res: Reponse) => {
-    logger = new Logger();
     logger.info(req.params.msg);
     logger.imp(req.params.msg);
     logger.warn(req.params.msg);
@@ -111,38 +97,24 @@ router.get('api/users/alt', async (req: Request, res: Reponse) => {
 
 
 ### Using a custom logger 
-For production you'll probably have some third party logging tool like ElasticSearch or Splunk. _logger_ exports one interface `ICustomLogger` which has one method `sendLog()` that needs to implemented. If you created a class which implements this interface, and add it to Logger through a setter or the constructor and set the mode to `CUSTOM`, Logger will call whatever logic you created for `sendLog()`.
-
-````typescript
-// CustomLoggerTool.ts
-import { ICustomLogger } from 'jet-logger';
+For production you'll probably have some third party logging tool like ElasticSearch or Splunk. _logger_ exports a type `TCustomLogger` that needs to implemented. If you implement this function and pass it to JetLogger and set the mode to `CUSTOM`, Logger will call whatever logic you created for `sendLog()`.
 
-export class CustomLoggerTool implements ICustomLogger {
-
-    private readonly thirdPartyLoggingApplication: ThirdPartyLoggingApplication;
-
-    constructor() {
-        this.thirdPartyLoggingApplication = new ThirdPartyLoggingApplication();
-    }
-
-    // Needs to be implemented
-    public sendLog(timestamp: Date, prefix: string, content: any): void {
-        this.thirdPartyLoggingApplication.doStuff(...);
-    }
-}
-````
 
 ````typescript
 // In the route file
 import { OK } from 'http-status-codes';
 import { Router, Request, Response } from 'express';
-import { CustomLoggerTool } from 'CustomLoggerTool';
+import { JetLogger, ICustomLogger } from 'jet-logger';
+import { thirdPartyLoggingApp } from 'thirdPartyLoggingApplicationLib';
 
-const customLoggerTool = new CustomLoggerTool();
 
+// Needs to be implemented
+const customSend: TCustomLogger = (timestamp: Date, level: string, content: any) => {
+    thirdPartyLoggingApp.doStuff(...);
+}
 
 router.get('api/users', async (req: Request, res: Reponse) => {
-    const logger = new Logger(LoggerModes.CUSTOM, '', true, customLoggerTool);
+    const logger = new Logger(LoggerModes.CUSTOM, '', true, customSend);
     logger.rmTimestamp = true;
     logger.info(req.params.msg);
     return res.status(OK).json({

package/lib/index.d.ts

@@ -1,3 +1,65 @@
-export { LoggerModes, Formats, ICustomLogger } from './constants';
-import Logger from './Logger';
-export default Logger;
+export declare enum LoggerModes {
+    Console = "CONSOLE",
+    File = "FILE",
+    Custom = "CUSTOM",
+    Off = "OFF"
+}
+export declare enum Formats {
+    Line = "LINE",
+    Json = "JSON"
+}
+declare const levels: {
+    info: {
+        color: string;
+        prefix: string;
+    };
+    imp: {
+        color: string;
+        prefix: string;
+    };
+    warn: {
+        color: string;
+        prefix: string;
+    };
+    err: {
+        color: string;
+        prefix: string;
+    };
+};
+declare const _default: Readonly<{
+    settings: {
+        mode: LoggerModes;
+        filePath: string;
+        timestamp: boolean;
+        format: Formats;
+        customLogger: TCustomLogger | undefined;
+    };
+    info: typeof info;
+    imp: typeof imp;
+    warn: typeof warn;
+    err: typeof err;
+    printLogHelper: typeof printLogHelper;
+}>;
+export default _default;
+declare type TLevelProp = typeof levels[keyof typeof levels];
+declare type TJetLogger = ReturnType<typeof JetLogger>;
+export declare type TCustomLogger = (timestamp: Date, prefix: string, content: any) => void;
+export declare function JetLogger(mode?: LoggerModes, filePath?: string, timestamp?: boolean, format?: Formats, customLogger?: TCustomLogger): Readonly<{
+    settings: {
+        mode: LoggerModes;
+        filePath: string;
+        timestamp: boolean;
+        format: Formats;
+        customLogger: TCustomLogger | undefined;
+    };
+    info: typeof info;
+    imp: typeof imp;
+    warn: typeof warn;
+    err: typeof err;
+    printLogHelper: typeof printLogHelper;
+}>;
+declare function info(this: TJetLogger, content: any, printFull?: boolean): void;
+declare function imp(this: TJetLogger, content: any, printFull?: boolean): void;
+declare function warn(this: TJetLogger, content: any, printFull?: boolean): void;
+declare function err(this: TJetLogger, content: any, printFull?: boolean): void;
+declare function printLogHelper(this: TJetLogger, content: any, printFull: boolean, level: TLevelProp): void;

package/lib/index.js

@@ -1,7 +1,177 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var Logger_1 = __importDefault(require("./Logger"));
-exports.default = Logger_1.default;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JetLogger = exports.Formats = exports.LoggerModes = void 0;
+var util_1 = __importDefault(require("util"));
+var colors_1 = __importDefault(require("colors"));
+var fs_1 = __importDefault(require("fs"));
+var LoggerModes;
+(function (LoggerModes) {
+    LoggerModes["Console"] = "CONSOLE";
+    LoggerModes["File"] = "FILE";
+    LoggerModes["Custom"] = "CUSTOM";
+    LoggerModes["Off"] = "OFF";
+})(LoggerModes = exports.LoggerModes || (exports.LoggerModes = {}));
+var Formats;
+(function (Formats) {
+    Formats["Line"] = "LINE";
+    Formats["Json"] = "JSON";
+})(Formats = exports.Formats || (exports.Formats = {}));
+var levels = {
+    info: {
+        color: 'green',
+        prefix: 'INFO',
+    },
+    imp: {
+        color: 'magenta',
+        prefix: 'IMPORTANT',
+    },
+    warn: {
+        color: 'yellow',
+        prefix: 'WARNING',
+    },
+    err: {
+        color: 'red',
+        prefix: 'ERROR',
+    }
+};
+var errors = {
+    customLoggerErr: 'Custom logger mode set to true, but no custom logger was provided.',
+    modeErr: 'The correct logger mode was not specified: Must be "CUSTOM", "FILE", ' +
+        '"OFF", or "CONSOLE".'
+};
+var defaults = {
+    fileName: 'jet-logger.log',
+    mode: LoggerModes.Console,
+    timestamp: true,
+    format: Formats.Line,
+};
+exports.default = JetLogger();
+function JetLogger(mode, filePath, timestamp, format, customLogger) {
+    return Object.freeze({
+        settings: getSettings(mode, filePath, timestamp, format, customLogger),
+        info: info,
+        imp: imp,
+        warn: warn,
+        err: err,
+        printLogHelper: printLogHelper,
+    });
+}
+exports.JetLogger = JetLogger;
+function getSettings(mode, filePath, timestamp, format, customLogger) {
+    if (!mode) {
+        if (!!process.env.JET_LOGGER_MODE) {
+            mode = process.env.JET_LOGGER_MODE.toUpperCase();
+        }
+        else {
+            mode = defaults.mode;
+        }
+    }
+    if (!filePath) {
+        if (!!process.env.JET_LOGGER_FILEPATH) {
+            filePath = process.env.JET_LOGGER_FILEPATH;
+        }
+        else {
+            filePath = defaults.fileName;
+        }
+    }
+    if (!timestamp) {
+        if (!!process.env.JET_LOGGER_TIMESTAMP) {
+            timestamp = (process.env.JET_LOGGER_TIMESTAMP.toUpperCase() === 'TRUE');
+        }
+        else {
+            timestamp = defaults.timestamp;
+        }
+    }
+    if (!format) {
+        if (!!process.env.JET_LOGGER_FORMAT) {
+            format = process.env.JET_LOGGER_FORMAT.toUpperCase();
+        }
+        else {
+            format = defaults.format;
+        }
+    }
+    return {
+        mode: mode,
+        filePath: filePath,
+        timestamp: timestamp,
+        format: format,
+        customLogger: customLogger,
+    };
+}
+function info(content, printFull) {
+    return this.printLogHelper(content, printFull !== null && printFull !== void 0 ? printFull : false, levels.info);
+}
+function imp(content, printFull) {
+    return this.printLogHelper(content, printFull !== null && printFull !== void 0 ? printFull : false, levels.imp);
+}
+function warn(content, printFull) {
+    return this.printLogHelper(content, printFull !== null && printFull !== void 0 ? printFull : false, levels.warn);
+}
+function err(content, printFull) {
+    return this.printLogHelper(content, printFull !== null && printFull !== void 0 ? printFull : false, levels.err);
+}
+function printLogHelper(content, printFull, level) {
+    return printLog(content, printFull, level, this.settings.mode, this.settings.timestamp, this.settings.format, this.settings.filePath, this.settings.customLogger);
+}
+function printLog(content, printFull, level, mode, timestamp, format, filePath, customLogger) {
+    if (mode === LoggerModes.Off) {
+        return;
+    }
+    var jsonContent = {};
+    if (printFull) {
+        content = util_1.default.inspect(content);
+    }
+    if (format === Formats.Json) {
+        jsonContent.message = content;
+    }
+    if (mode !== LoggerModes.Custom) {
+        if (format === Formats.Line) {
+            content = level.prefix + ': ' + content;
+        }
+        else if (format === Formats.Json) {
+            jsonContent.level = level.prefix;
+        }
+    }
+    if (timestamp) {
+        if (format === Formats.Line) {
+            var time = '[' + new Date().toISOString() + '] ';
+            content = time + content;
+        }
+        else if (format === Formats.Json) {
+            jsonContent.timestamp = new Date().toISOString();
+        }
+    }
+    if (format === Formats.Json) {
+        content = JSON.stringify(jsonContent);
+    }
+    if (mode === LoggerModes.Console) {
+        var colorFn = colors_1.default[level.color];
+        console.log(colorFn(content));
+    }
+    else if (mode === LoggerModes.File) {
+        writeToFile(content + '\n', filePath).catch(function (err) {
+            console.log(err);
+        });
+    }
+    else if (mode === LoggerModes.Custom) {
+        if (!!customLogger) {
+            customLogger(new Date(), level.prefix, content);
+        }
+        else {
+            throw Error(errors.customLoggerErr);
+        }
+    }
+    else {
+        throw Error(errors.modeErr);
+    }
+}
+function writeToFile(content, filePath) {
+    return new Promise(function (res, rej) {
+        return fs_1.default.appendFile(filePath, content, function (err) {
+            return (!!err ? rej(err) : res());
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jet-logger",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "A super quick, easy to setup logging tool for NodeJS/TypeScript.",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://github.com/seanpmaxwell/jet-logger#readme",
   "dependencies": {
-    "colors": "^1.4.0"
+    "colors": "1.3.0"
   },
   "devDependencies": {
     "@types/node": "^14.11.8",

package/lib/Logger.d.ts

@@ -1,54 +0,0 @@
-import { LoggerModes, Formats, ICustomLogger } from './constants';
-declare class Logger {
-    static readonly DEFAULT_LOG_FILE_NAME = "jet-logger.log";
-    static readonly CUSTOM_LOGGER_ERR: string;
-    private static _mode;
-    private static _filePath;
-    private static _timestamp;
-    private static _format;
-    private static _customLogger;
-    private _mode;
-    private _filePath;
-    private _timestamp;
-    private _format;
-    private _customLogger;
-    constructor(mode?: LoggerModes, filePath?: string, timestamp?: boolean, format?: Formats, customLogger?: ICustomLogger);
-    private static initMode;
-    private static initFilePath;
-    private static initTimestamp;
-    private static initFormat;
-    static get mode(): LoggerModes;
-    static set mode(mode: LoggerModes);
-    get mode(): LoggerModes;
-    set mode(mode: LoggerModes);
-    static get filePath(): string;
-    static set filePath(filePath: string);
-    get filePath(): string;
-    set filePath(filePath: string);
-    static get timestamp(): boolean;
-    static set timestamp(timestamp: boolean);
-    get timestamp(): boolean;
-    set timestamp(timestamp: boolean);
-    static get format(): Formats;
-    static set format(format: Formats);
-    get format(): Formats;
-    set format(format: Formats);
-    static set customLogger(customLogger: ICustomLogger | null);
-    static get customLogger(): ICustomLogger | null;
-    set customLogger(customLogger: ICustomLogger | null);
-    get customLogger(): ICustomLogger | null;
-    static Info(content: any, printFull?: boolean): void;
-    static Imp(content: any, printFull?: boolean): void;
-    static Warn(content: any, printFull?: boolean): void;
-    static Err(content: any, printFull?: boolean): void;
-    private static PrintLogHelper;
-    info(content: any, printFull?: boolean): void;
-    imp(content: any, printFull?: boolean): void;
-    warn(content: any, printFull?: boolean): void;
-    err(content: any, printFull?: boolean): void;
-    private printLogHelper;
-    private static PrintLog;
-    private static WriteToFile;
-    private static CheckExists;
-}
-export default Logger;

package/lib/Logger.js

@@ -1,281 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var colors_1 = __importDefault(require("colors"));
-var fs_1 = __importDefault(require("fs"));
-var util_1 = __importDefault(require("util"));
-var Levels = {
-    info: {
-        color: 'green',
-        prefix: 'INFO',
-    },
-    imp: {
-        color: 'magenta',
-        prefix: 'IMPORTANT',
-    },
-    warn: {
-        color: 'yellow',
-        prefix: 'WARNING',
-    },
-    err: {
-        color: 'red',
-        prefix: 'ERROR',
-    }
-};
-var Logger = (function () {
-    function Logger(mode, filePath, timestamp, format, customLogger) {
-        this._mode = mode || Logger.initMode();
-        this._filePath = filePath || Logger.initFilePath();
-        this._timestamp = (timestamp !== undefined ? timestamp : Logger.initTimestamp());
-        this._format = format || Logger.initFormat();
-        this._customLogger = customLogger || Logger.customLogger;
-    }
-    Logger.initMode = function () {
-        if (!!process.env.JET_LOGGER_MODE) {
-            return process.env.JET_LOGGER_MODE.toLocaleUpperCase();
-        }
-        else {
-            return "CONSOLE";
-        }
-    };
-    Logger.initFilePath = function () {
-        if (!!process.env.JET_LOGGER_FILEPATH) {
-            return process.env.JET_LOGGER_FILEPATH;
-        }
-        else {
-            return Logger.DEFAULT_LOG_FILE_NAME;
-        }
-    };
-    Logger.initTimestamp = function () {
-        if (!!process.env.JET_LOGGER_TIMESTAMP) {
-            return (process.env.JET_LOGGER_TIMESTAMP.toLocaleUpperCase() === 'TRUE');
-        }
-        else {
-            return true;
-        }
-    };
-    Logger.initFormat = function () {
-        if (!!process.env.JET_LOGGER_FORMAT) {
-            return process.env.JET_LOGGER_FORMAT.toLocaleUpperCase();
-        }
-        else {
-            return "LINE";
-        }
-    };
-    Object.defineProperty(Logger, "mode", {
-        get: function () {
-            return Logger._mode;
-        },
-        set: function (mode) {
-            Logger._mode = mode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger.prototype, "mode", {
-        get: function () {
-            return this._mode;
-        },
-        set: function (mode) {
-            this._mode = mode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger, "filePath", {
-        get: function () {
-            return Logger._filePath;
-        },
-        set: function (filePath) {
-            Logger._filePath = filePath;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger.prototype, "filePath", {
-        get: function () {
-            return this._filePath;
-        },
-        set: function (filePath) {
-            this._filePath = filePath;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger, "timestamp", {
-        get: function () {
-            return Logger._timestamp;
-        },
-        set: function (timestamp) {
-            Logger._timestamp = timestamp;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger.prototype, "timestamp", {
-        get: function () {
-            return this._timestamp;
-        },
-        set: function (timestamp) {
-            this._timestamp = timestamp;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger, "format", {
-        get: function () {
-            return Logger._format;
-        },
-        set: function (format) {
-            Logger._format = format;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger.prototype, "format", {
-        get: function () {
-            return this._format;
-        },
-        set: function (format) {
-            this._format = format;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger, "customLogger", {
-        get: function () {
-            return Logger._customLogger;
-        },
-        set: function (customLogger) {
-            Logger._customLogger = customLogger;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Logger.prototype, "customLogger", {
-        get: function () {
-            return this._customLogger;
-        },
-        set: function (customLogger) {
-            this._customLogger = customLogger;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Logger.Info = function (content, printFull) {
-        Logger.PrintLogHelper(content, printFull || false, Levels.info);
-    };
-    Logger.Imp = function (content, printFull) {
-        Logger.PrintLogHelper(content, printFull || false, Levels.imp);
-    };
-    Logger.Warn = function (content, printFull) {
-        Logger.PrintLogHelper(content, printFull || false, Levels.warn);
-    };
-    Logger.Err = function (content, printFull) {
-        Logger.PrintLogHelper(content, printFull || false, Levels.err);
-    };
-    Logger.PrintLogHelper = function (content, printFull, level) {
-        Logger.PrintLog(content, printFull, level, Logger.mode, Logger.timestamp, Logger.format, Logger.filePath, Logger.customLogger);
-    };
-    Logger.prototype.info = function (content, printFull) {
-        this.printLogHelper(content, printFull || false, Levels.info);
-    };
-    Logger.prototype.imp = function (content, printFull) {
-        this.printLogHelper(content, printFull || false, Levels.imp);
-    };
-    Logger.prototype.warn = function (content, printFull) {
-        this.printLogHelper(content, printFull || false, Levels.warn);
-    };
-    Logger.prototype.err = function (content, printFull) {
-        this.printLogHelper(content, printFull || false, Levels.err);
-    };
-    Logger.prototype.printLogHelper = function (content, printFull, level) {
-        Logger.PrintLog(content, printFull, level, this.mode, this.timestamp, this.format, this.filePath, this.customLogger);
-    };
-    Logger.PrintLog = function (content, printFull, level, mode, timestamp, format, filePath, customLogger) {
-        if (mode === "OFF") {
-            return;
-        }
-        var jsonContent = {};
-        if (printFull) {
-            content = util_1.default.inspect(content);
-        }
-        if (format === "JSON") {
-            jsonContent.message = content;
-        }
-        if (mode !== "CUSTOM") {
-            if (format === "LINE") {
-                content = level.prefix + ': ' + content;
-            }
-            else if (format === "JSON") {
-                jsonContent.level = level.prefix;
-            }
-        }
-        if (timestamp) {
-            if (format === "LINE") {
-                var time = '[' + new Date().toISOString() + '] ';
-                content = time + content;
-            }
-            else if (format === "JSON") {
-                jsonContent.timestamp = new Date().toISOString();
-            }
-        }
-        if (format === "JSON") {
-            content = JSON.stringify(jsonContent);
-        }
-        if (mode === "CONSOLE") {
-            var colorFn = colors_1.default[level.color];
-            console.log(colorFn(content));
-        }
-        else if (mode === "FILE") {
-            Logger.WriteToFile(content + '\n', filePath);
-        }
-        else if (mode === "CUSTOM") {
-            if (!!customLogger) {
-                customLogger.sendLog(new Date(), level.prefix, content);
-            }
-            else {
-                throw Error(Logger.CUSTOM_LOGGER_ERR);
-            }
-        }
-        else {
-            throw Error('The correct logger mode was not specified: Must be "CUSTOM", "FILE", ' +
-                '"OFF", or "CONSOLE".');
-        }
-    };
-    Logger.WriteToFile = function (content, filePath) {
-        try {
-            var fileExists = Logger.CheckExists(filePath);
-            if (fileExists) {
-                fs_1.default.appendFileSync(filePath, content);
-            }
-            else {
-                fs_1.default.writeFileSync(filePath, content);
-            }
-        }
-        catch (err) {
-            console.error(err);
-        }
-    };
-    Logger.CheckExists = function (filePath) {
-        try {
-            fs_1.default.accessSync(filePath);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    };
-    Logger.DEFAULT_LOG_FILE_NAME = 'jet-logger.log';
-    Logger.CUSTOM_LOGGER_ERR = 'Custom logger mode set to true, but no ' +
-        'custom logger was provided.';
-    Logger._mode = Logger.initMode();
-    Logger._filePath = Logger.initFilePath();
-    Logger._timestamp = Logger.initTimestamp();
-    Logger._format = Logger.initFormat();
-    Logger._customLogger = null;
-    return Logger;
-}());
-exports.default = Logger;

package/lib/constants.d.ts

@@ -1,13 +0,0 @@
-export interface ICustomLogger {
-    sendLog(timestamp: Date, prefix: string, content: any): void;
-}
-export declare const enum LoggerModes {
-    Console = "CONSOLE",
-    File = "FILE",
-    Custom = "CUSTOM",
-    Off = "OFF"
-}
-export declare const enum Formats {
-    Line = "LINE",
-    Json = "JSON"
-}

package/lib/constants.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });