Migrated .js files to .ts.

Started updating tests.

Author: justinkames

.npmignore

@@ -1,40 +1,38 @@
 {
-  "name": "vuejs-logger",
-  "author": "Justin Kames",
-  "version": "1.4.0",
-  "description": "Vuejs-logger, provides customizable logging functionality for Vue.js.",
-  "main": "dist/index.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/justinkames/vuejs-logger.git"
-  },
+  "name": "mean-poc",
+  "version": "0.0.0",
+  "private": true,
+  "main": "index.js",
   "scripts": {
-    "test": "istanbul cover _mocha -- --compilers js:babel-core/register -R spec --debug",
-    "upload-coverage": "codecov -t $CODECOV_TOKEN",
-    "build-transpile-uglify": "node_modules/babel-cli/bin/babel.js src --out-dir dist && node_modules/uglify-js/bin/uglifyjs dist/logger.js -c -m -o dist/logger.js",
-    "build-transpile": "node_modules/babel-cli/bin/babel.js src --out-dir dist && node_modules/uglify-js/bin/uglifyjs dist/logger.js -c -m -o dist/logger.js",
-    "prepublish": "npm test && npm run build-transpile-uglify"
-  },
-  "license": "MIT",
-  "babel": {
-    "presets": [
-      "es2015"
-    ],
-    "plugins": [
-      "transform-object-assign"
-    ]
+    "build": "tsc",
+    "tsc": "tsc",
+    "test": "tsc && jest"
   },
   "devDependencies": {
-    "babel-cli": "6.24.1",
-    "babel-core": "6.25.0",
-    "babel-loader": "7.1.1",
-    "babel-plugin-transform-object-assign": "6.22.0",
-    "babel-preset-es2015": "6.24.1",
-    "chai": "4.1.0",
-    "codecov": "2.2.0",
-    "istanbul": "1.1.0-alpha.1",
-    "mocha": "3.4.2",
-    "uglify": "0.1.5",
-    "vue": "2.5.13"
+    "@types/jest": "23.3.1",
+    "@types/node": "10.5.3",
+    "eslint": "5.2.0",
+    "jest": "23.4.1",
+    "ts-jest": "23.0.1",
+    "tsc": "1.20150623.0",
+    "typescript": "2.9.2",
+    "chai": "4.1.2",
+    "vue": "2.5.16"
+  },
+  "jest": {
+    "verbose": true,
+    "testURL": "http://localhost/",
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ]
   }
 }

package.json

@@ -0,0 +1,7 @@
+export enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    FATAL = "fatal",
+}

src/enum/log-levels.ts

@@ -0,0 +1,3 @@
+import VueLogger from "./vue-logger";
+
+export default VueLogger;

src/index.js

@@ -0,0 +1,11 @@
+import {LogLevel} from "../enum/log-levels";
+
+export interface ILoggerOptions {
+    isEnabled: boolean;
+    logLevel: LogLevel;
+    separator: string;
+    showConsoleColors: boolean;
+    showLogLevel: boolean;
+    showMethodName: boolean;
+    stringifyArguments: boolean;
+}

src/index.ts

@@ -0,0 +1,16 @@
+import {ILoggerOptions} from "./logger-options";
+
+export interface ILogger {
+
+    install(Vue: any, options: ILoggerOptions);
+
+    initLoggerInstance(options: ILoggerOptions, logLevels: string[]);
+
+    print(logLevel: string, logLevelPrefix: string, methodNamePrefix: string, formattedArguments: any[], showConsoleColors: boolean);
+
+    isValidOptions(options: ILoggerOptions, logLevels: string[]): boolean;
+
+    getMethodName();
+
+    getDefaultOptions(): ILoggerOptions;
+}

src/interfaces/logger-options.ts

@@ -0,0 +1,107 @@
+import {LogLevel} from "./enum/log-levels";
+import {ILogger} from "./interfaces/logger";
+import {ILoggerOptions} from "./interfaces/logger-options";
+
+class VueLogger implements ILogger {
+
+    public errorMessage: string = "Provided options for vuejs-logger are not valid.";
+    public logLevels: string[] = Object.keys(LogLevel).map((l) => l.toLowerCase());
+
+    public install(Vue: any, options: ILoggerOptions) {
+        options = Object.assign(this.getDefaultOptions(), options);
+
+        if (this.isValidOptions(options, this.logLevels)) {
+            Vue.$log = this.initLoggerInstance(options, this.logLevels);
+            Vue.prototype.$log = Vue.$log;
+        } else {
+            throw new Error(this.errorMessage);
+        }
+    }
+
+    public getMethodName(): string {
+        let error = {stack: ""};
+
+        try {
+            throw new Error("");
+        } catch (e) {
+            error = e;
+        }
+        // IE9 does not have .stack property
+        if (error.stack === undefined) {
+            return "";
+        }
+        let stackTrace = error.stack.split("\n")[3];
+        if (/ /.test(stackTrace)) {
+            stackTrace = stackTrace.trim().split(" ")[1];
+        }
+        if (stackTrace && stackTrace.includes(".")) {
+            stackTrace = stackTrace.split(".")[1];
+        }
+        return stackTrace;
+    }
+
+    public initLoggerInstance(options: ILoggerOptions, logLevels: string[]) {
+        const logger = {};
+        logLevels.forEach((logLevel) => {
+                if (logLevels.indexOf(logLevel) >= logLevels.indexOf(options.logLevel) &&
+                    options.isEnabled) {
+                    logger[logLevel] = (...args) => {
+                        const methodName = this.getMethodName();
+                        const methodNamePrefix = options.showMethodName ? methodName + ` ${options.separator} ` : "";
+                        const logLevelPrefix = options.showLogLevel ? logLevel + ` ${options.separator} ` : "";
+                        const formattedArguments = options.stringifyArguments ? args.map((a) => JSON.stringify(a)) : args;
+                        this.print(logLevel, logLevelPrefix, methodNamePrefix, formattedArguments, options.showConsoleColors);
+                    };
+                } else {
+                    logger[logLevel] = () => {
+                    };
+                }
+            },
+        );
+        return logger;
+    }
+
+    public isValidOptions(options: ILoggerOptions, logLevels: string[]): boolean {
+        if (!(options.logLevel && typeof options.logLevel === "string" && logLevels.indexOf(options.logLevel) > -1)) {
+            return false;
+        }
+        if (options.stringifyArguments && typeof options.stringifyArguments !== "boolean") {
+            return false;
+        }
+        if (options.showLogLevel && typeof options.showLogLevel !== "boolean") {
+            return false;
+        }
+        if (options.showConsoleColors && typeof options.showConsoleColors !== "boolean") {
+            return false;
+        }
+        if (options.separator && (typeof options.separator !== "string" || (typeof options.separator === "string" && options.separator.length > 3))) {
+            return false;
+        }
+        if (typeof options.isEnabled !== "boolean") {
+            return false;
+        }
+        return !(options.showMethodName && typeof options.showMethodName !== "boolean");
+    }
+
+    public print(logLevel: string, logLevelPrefix: string, methodNamePrefix: string, formattedArguments: any[], showConsoleColors: boolean) {
+        if (showConsoleColors && (logLevel === "warn" || logLevel === "error" || logLevel === "fatal")) {
+            console[logLevel === "fatal" ? "error" : logLevel](logLevelPrefix, methodNamePrefix, ...formattedArguments);
+        } else {
+            console.log(logLevelPrefix, methodNamePrefix, ...formattedArguments);
+        }
+    }
+
+    public getDefaultOptions(): ILoggerOptions {
+        return {
+            isEnabled: true,
+            logLevel: LogLevel.DEBUG,
+            separator: "|",
+            showConsoleColors: false,
+            showLogLevel: false,
+            showMethodName: false,
+            stringifyArguments: false,
+        };
+    }
+}
+
+export default new VueLogger();