analogger 1.5.1 → 1.5.2

package/CHANGELOG.md

@@ -1,5 +1,5 @@
-## [1.5.1](https://github.com/thimpat/analogger/compare/v1.5.0...v1.5.1) (2022-02-11)
-
+## [1.5.1](https://github.com/thimpat/analogger/compare/v1.5.0...v1.5.1) (2022-02-11)
+
 # [1.5.0](https://github.com/thimpat/analogger/compare/v1.4.1...v1.5.0) (2022-02-11)
 
 ## [1.4.1](https://github.com/thimpat/analogger/compare/v1.4.0...v1.4.1) (2022-02-09)
@@ -10,4 +10,4 @@
 
 ## [1.3.1](https://github.com/thimpat/analogger/compare/v1.3.0...v1.3.1) (2022-02-09)
 
-# [1.3.0](https://github.com/thimpat/analogger/compare/v1.2.0...v1.3.0) (2022-02-08)
+# [1.3.0](https://github.com/thimpat/analogger/compare/v1.2.0...v1.3.0) (2022-02-08)

package/dist/index-cjs.min.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var require$$0=require("chalk-cjs"),require$$1=require("color-convert-cjs"),require$$2=require("rgb-hex-cjs");function _interopDefaultLegacy(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var require$$0__default=_interopDefaultLegacy(require$$0),require$$1__default=_interopDefaultLegacy(require$$1),require$$2__default=_interopDefaultLegacy(require$$2),anaLogger={},constants$1={};const constants={COLOR_TABLE:["#d2466e","#FFA07A","#FF7F50","#FF6347","#FFE4B5","#ADFF2F","#808000","#40E0D0","#1E90FF","#EE82EE","#708090","#DEB887","#FE642E","#210B61","#088A4B","#5E610B","#FA8258","#088A68","#B40431"],SYSTEM:{BROWSER:"BROWSER",NODE:"NODE"}},chalk=(constants$1.COLOR_TABLE=constants.COLOR_TABLE,constants$1.SYSTEM=constants.SYSTEM,require$$0__default.default),colorConvert=require$$1__default.default,rgbHex=require$$2__default.default,{COLOR_TABLE,SYSTEM}=constants$1,EOL=`
+`;class AnaLogger{system="";logIndex=0;contexts=[];targets={};activeTarget=null;indexColor=0;format="";keepLog=!1;logHistory=[];$containers=null;options={hideHookMessage:!1};static ALIGN={LEFT:"LEFT",RIGHT:"RIGHT"};static ENVIRONMENT_TYPE={BROWSER:"BROWSER",NODE:"NODE",OTHER:"OTHER"};originalFormatFunction;constructor(){this.system="object"==typeof process?SYSTEM.NODE:SYSTEM.BROWSER,this.format=this.onBuildLog.bind(this),this.originalFormatFunction=this.format,this.errorTargetHandler=this.onError.bind(this),this.errorUserTargetHandler=this.onErrorForUserTarget.bind(this),this.setOptions(this.options),this.realConsoleLog=console.log,this.realConsoleInfo=console.info,this.realConsoleWarn=console.warn,this.realConsoleError=console.error,this.ALIGN=AnaLogger.ALIGN,this.ENVIRONMENT_TYPE=AnaLogger.ENVIRONMENT_TYPE}keepLogHistory(){this.keepLog=!0}releaseLogHistory(){this.keepLog=!1}resetLogHistory(){this.logHistory=[]}getLogHistory(e=!0,t=EOL){const o=JSON.parse(JSON.stringify(this.logHistory.slice(0)));return e?o.join(t):o}isNode(){return this.system===SYSTEM.NODE}isBrowser(){return!this.isNode()}setOptions({contextLenMax:e=10,idLenMax:t=5,lidLenMax:o=5,symbolLenMax:r=2,messageLenMax:s=60,hideLog:n=!1,hideError:i=!1,hideHookMessage:a=!1,showPassingTests:l=!0,logToDom:g=void 0,silent:h=!1}={}){this.options.contextLenMax=e,this.options.idLenMax=t,this.options.lidLenMax=o,this.options.messageLenMax=s,this.options.symbolLenMax=r,this.options.hideLog=!!n,this.options.hideError=!!i,this.options.hideHookMessage=!!a,this.options.showPassingTests=!!l,void 0!==g&&(this.options.logToDom=g||"#analogger"),h&&(this.options.hideLog=!0,this.options.hideHookMessage=!0,this.options.silent=!0)}getOptions(){return this.options}truncateMessage(e="",{fit:t=0,align:o=AnaLogger.ALIGN.LEFT}){return e=""+e,t&&e.length>=t+2&&(e=e.substring(0,t-3)+"..."),e=o===AnaLogger.ALIGN.LEFT?e.padEnd(t+1," "):e.padStart(t+1," ")}onBuildLog({contextName:e,message:t="",lid:o="",symbol:r=""}={}){const s=new Date;var n=("0"+s.getHours()).slice(-2)+":"+("0"+s.getMinutes()).slice(-2)+":"+("0"+s.getSeconds()).slice(-2),n=this.truncateMessage(n,{fit:7});return e=this.truncateMessage(e,{fit:this.options.contextLenMax,align:AnaLogger.ALIGN.RIGHT}),o=this.truncateMessage(o,{fit:this.options.lidLenMax}),t=this.truncateMessage(t,{fit:this.options.messageLenMax}),`[${n}] ${e}: (${o}) ${r=this.truncateMessage(r,{fit:this.options.symbolLenMax})} `+t}onErrorForUserTarget(e,...t){this.errorUserTargetHandler(e,...t)}onError(e,...t){e.target===this.targets.USER&&this.onErrorForUserTarget(e,...t)}onDisplayLog(...e){this.log(...e)}onDisplayError(...e){this.error(...e)}setLogFormat(e){if("function"!=typeof e)return console.error("Invalid parameter for setFormat. It is expecting a function or method."),!1;this.format=e.bind(this)}resetLogFormatter(){this.format=this.originalFormatFunction}setErrorHandler(e){this.errorTargetHandler=e.bind(this)}setErrorHandlerForUserTarget(e){this.errorUserTargetHandler=e.bind(this)}isContextValid(e){return"object"==typeof e&&!Array.isArray(e)&&null!==e&&(e.hasOwnProperty("contextName")&&e.hasOwnProperty("target"))}generateDefaultContext(){const e={name:"DEFAULT",contextName:"DEFAULT",target:"ALL",symbol:"⚡"};return e.id=this.logIndex++,e.color=COLOR_TABLE[1],e}generateNewContext(){const e=this.generateDefaultContext();return e.color=COLOR_TABLE[this.indexColor++%(COLOR_TABLE.length-3)+2],e.symbol="",e}generateErrorContext(){const e=this.generateDefaultContext();return e.color=COLOR_TABLE[0],e.symbol="v",e.error=!0,e}#allegeProperties(e){let t=e;e=this.generateNewContext();return t=Object.assign({},e,t),-1<t.color.toLowerCase().indexOf("rgb")?t.color="#"+rgbHex(t.color):-1===t.color.indexOf("#")&&colorConvert&&(t.color="#"+colorConvert.keyword.hex(t.color)),t}setContexts(o){const e=Object.keys(o);o.DEFAULT=this.contexts.DEFAULT=this.generateDefaultContext(),o.ERROR=this.contexts.ERROR=this.generateErrorContext(),e.forEach(e=>{const t=o[e]||{};t.contextName=e,t.name=e,this.contexts[e]=this.#allegeProperties(t),o[e]=this.contexts[e]})}setTargets(e={}){this.targets=Object.assign({},e,{ALL:"ALL",USER:"USER"})}setActiveTarget(e){this.activeTarget=e}isTargetAllowed(e){return!e||!this.activeTarget||(e===this.targets.ALL||this.activeTarget===e)}writeLogToDom(o){this.$containers=this.$containers||document.querySelectorAll(this.options.logToDom);for(let t=0;t<this.$containers.length;++t){const r=this.$containers[t];let e=r.querySelector(".analogger-view");e||(e=document.createElement("div"),e.classList.add("analogger-view"),r.append(e));const s=document.createElement("div"),n=(s.classList.add("to-esm-line"),s.textContent=o,document.createElement("span"));n.classList.add("to-esm-row"),s.append(n),e.append(s)}}processOutput(o={}){try{if(!this.isTargetAllowed(o.target))return;let e=Array.prototype.slice.call(arguments);e.shift();var r=e.join(" | ");let t="";var s=this.format({...o,message:r});if(t=this.isBrowser()?(o.environnment=AnaLogger.ENVIRONMENT_TYPE.BROWSER,this.options.logToDom&&this.writeLogToDom(s),"%c"+s):(o.environnment=AnaLogger.ENVIRONMENT_TYPE.NODE,chalk.hex(o.color)(s)),this.keepLog&&this.logHistory.push(t),this.options.hideLog)return;this.isBrowser()?this.realConsoleLog(t,"color: "+o.color):this.realConsoleLog(t),this.errorTargetHandler(o,e)}catch(e){console.error("AnaLogger:",e.message)}}isExtendedOptionsPassed(e){return"object"==typeof e&&(e.hasOwnProperty("context")||e.hasOwnProperty("target"))}convertToContext(e,t){t=t||this.generateDefaultContext();let o=e=e||t;if(e.context&&"object"==typeof e.context){const r=Object.assign({},e);delete r.context,o=Object.assign({},e.context,r)}return o=Object.assign({},t,o),delete o.context,o}log(e,...t){if(!this.isExtendedOptionsPassed(e))return o=this.generateDefaultContext(),void this.processOutput.apply(this,[o,e,...t]);var o=this.convertToContext(e);this.processOutput.apply(this,[o,...t])}error(e){var t;this.options.hideError||(t=this.generateErrorContext(),e=this.convertToContext(e,t),t=Array.prototype.slice.call(arguments),this.log(e,...t))}overrideError(){this.options.hideHookMessage||this.realConsoleLog("AnaLogger: Hook placed on console.error"),console.error=this.onDisplayError.bind(this)}overrideConsole({log:e=!0,info:t=!0,warn:o=!0,error:r=!1}={}){this.options.hideHookMessage||this.realConsoleLog("AnaLogger: Hook placed on console.log"),e&&(console.log=this.onDisplayLog.bind(this)),t&&(console.info=this.onDisplayLog.bind(this)),o&&(console.warn=this.onDisplayLog.bind(this)),r&&this.overrideError()}removeOverrideError(){console.warn=this.realConsoleError}removeOverride({log:e=!0,info:t=!0,warn:o=!0,error:r=!1}={}){e&&(console.log=this.realConsoleLog),t&&(console.info=this.realConsoleInfo),o&&(console.warn=this.realConsoleWarn),r&&this.removeOverrideError()}info(...e){return this.log(...e)}warn(...e){return this.log(...e)}alert(...e){if(this.isNode())return this.log(...e);e=e.join(" | ");alert(e)}assert(e,t=!0,...o){try{return"function"==typeof e?e(...o)!==t?(this.error("Asset failed"),!1):(this.options.showPassingTests&&this.log("SUCCESS: Assert passed"),!0):e!==t?(this.error("Assert failed"),!1):(this.options.showPassingTests&&this.log("SUCCESS: Assert passed"),!0)}catch(e){this.error("Unexpected error in assert")}return!1}}var anaLogger_1=anaLogger.anaLogger=new AnaLogger;exports.anaLogger=anaLogger_1,exports.default=anaLogger;

package/dist/index-esm.min.mjs

@@ -0,0 +1,734 @@
+function rgbHex(red, green, blue, alpha) {
+	const isPercent = (red + (alpha || '')).toString().includes('%');
+
+	if (typeof red === 'string') {
+		[red, green, blue, alpha] = red.match(/(0?\.?\d{1,3})%?\b/g).map(component => Number(component));
+	} else if (alpha !== undefined) {
+		alpha = Number.parseFloat(alpha);
+	}
+
+	if (typeof red !== 'number' ||
+		typeof green !== 'number' ||
+		typeof blue !== 'number' ||
+		red > 255 ||
+		green > 255 ||
+		blue > 255
+	) {
+		throw new TypeError('Expected three numbers below 256');
+	}
+
+	if (typeof alpha === 'number') {
+		if (!isPercent && alpha >= 0 && alpha <= 1) {
+			alpha = Math.round(255 * alpha);
+		} else if (isPercent && alpha >= 0 && alpha <= 100) {
+			alpha = Math.round(255 * alpha / 100);
+		} else {
+			throw new TypeError(`Expected alpha value (${alpha}) as a fraction or percentage`);
+		}
+
+		alpha = (alpha | 1 << 8).toString(16).slice(1); // eslint-disable-line no-mixed-operators
+	} else {
+		alpha = '';
+	}
+
+	// TODO: Remove this ignore comment.
+	// eslint-disable-next-line no-mixed-operators
+	return ((blue | green << 8 | red << 16) | 1 << 24).toString(16).slice(1) + alpha;
+}
+
+/**
+ * DO NOT EDIT THIS FILE DIRECTLY.
+ * This file is generated following the conversion of 
+ * [src/cjs/constants.cjs]
+ * 
+ **/    
+const constants = {
+    COLOR_TABLE: [
+        "#d2466e",                  // Error context color
+        "#FFA07A",                  // Default context color
+        "#FF7F50",
+        "#FF6347",
+        "#FFE4B5",
+        "#ADFF2F",
+        "#808000",
+        "#40E0D0",
+        "#1E90FF",
+        "#EE82EE",
+        "#708090",
+        "#DEB887",
+        "#FE642E",
+        "#210B61",
+        "#088A4B",
+        "#5E610B",
+        "#FA8258",
+        "#088A68",
+        "#B40431",
+    ],
+    SYSTEM: {
+        BROWSER: "BROWSER",
+        NODE: "NODE"
+    }
+
+};
+
+const COLOR_TABLE = constants.COLOR_TABLE;
+const SYSTEM = constants.SYSTEM;
+
+/**
+ * DO NOT EDIT THIS FILE DIRECTLY.
+ * This file is generated following the conversion of 
+ * [src/cjs/ana-logger.cjs]
+ * 
+ **/    
+const chalk = null;
+const EOL =`
+`;
+
+class AnaLogger
+{
+    system = ""
+
+    logIndex = 0;
+    contexts = [];
+    targets = {};
+
+    activeTarget = null;
+
+    indexColor = 0;
+
+    format = "";
+
+    keepLog = false;
+    logHistory = []
+
+    $containers = null
+
+    options = {
+        hideHookMessage: false
+    }
+
+    static ALIGN = {
+        LEFT : "LEFT",
+        RIGHT: "RIGHT"
+    }
+
+    static ENVIRONMENT_TYPE = {
+        BROWSER: "BROWSER",
+        NODE   : "NODE",
+        OTHER  : "OTHER"
+    }
+    originalFormatFunction;
+
+    constructor()
+    {
+        this.system = (typeof process === "object") ? SYSTEM.NODE : SYSTEM.BROWSER;
+        this.format = this.onBuildLog.bind(this);
+        this.originalFormatFunction = this.format;
+
+        this.errorTargetHandler = this.onError.bind(this);
+        this.errorUserTargetHandler = this.onErrorForUserTarget.bind(this);
+
+        this.setOptions(this.options);
+
+        this.realConsoleLog = console.log;
+        this.realConsoleInfo = console.info;
+        this.realConsoleWarn = console.warn;
+        this.realConsoleError = console.error;
+
+        this.ALIGN = AnaLogger.ALIGN;
+        this.ENVIRONMENT_TYPE = AnaLogger.ENVIRONMENT_TYPE;
+    }
+
+    keepLogHistory()
+    {
+        this.keepLog = true;
+    }
+
+    releaseLogHistory()
+    {
+        this.keepLog = false;
+    }
+
+    resetLogHistory()
+    {
+        this.logHistory = [];
+    }
+
+    getLogHistory(join = true, symbol = EOL)
+    {
+        const history = JSON.parse(JSON.stringify(this.logHistory.slice(0)));
+        if (!join)
+        {
+            return history;
+        }
+        return history.join(symbol);
+    }
+
+    /**
+     * Tell whether we are in a Node environment
+     * @returns {boolean}
+     */
+    isNode()
+    {
+        return this.system === SYSTEM.NODE
+    }
+
+    /**
+     * Tell whether the logger runs from a browser
+     * @returns {boolean}
+     */
+    isBrowser()
+    {
+        return !this.isNode()
+    }
+
+    setOptions({
+                   contextLenMax = 10,
+                   idLenMax = 5,
+                   lidLenMax = 5,
+                   symbolLenMax = 2,
+                   messageLenMax = 60,
+                   hideLog = false,
+                   hideError = false,
+                   hideHookMessage = false,
+                   showPassingTests = true,
+                   logToDom = undefined,
+        silent = false
+               } = {})
+    {
+        this.options.contextLenMax = contextLenMax;
+        this.options.idLenMax = idLenMax;
+        this.options.lidLenMax = lidLenMax;
+        this.options.messageLenMax = messageLenMax;
+        this.options.symbolLenMax = symbolLenMax;
+        this.options.hideLog = !!hideLog;
+        this.options.hideError = !!hideError;
+        this.options.hideHookMessage = !!hideHookMessage;
+        this.options.showPassingTests = !!showPassingTests;
+        if (logToDom !== undefined)
+        {
+            this.options.logToDom = logToDom || "#analogger";
+        }
+
+        if (silent)
+        {
+            this.options.hideLog = true;
+            this.options.hideHookMessage = true;
+            this.options.silent = true;
+        }
+    }
+
+    getOptions()
+    {
+        return this.options
+    }
+
+    truncateMessage(input = "", {fit = 0, align = AnaLogger.ALIGN.LEFT})
+    {
+        input = "" + input;
+        if (fit && input.length >= fit + 2)
+        {
+            input = input.substring(0, fit - 3) + "...";
+        }
+
+        input = align === AnaLogger.ALIGN.LEFT ? input.padEnd(fit + 1, " ") : input.padStart(fit + 1, " ");
+        return input
+    }
+
+    /**
+     * Format inputs
+     * @see Override {@link setLogFormat}
+     * @param contextName
+     * @param id
+     * @param message
+     * @param lid
+     * @param symbol
+     * @returns {string}
+     */
+    onBuildLog({contextName, id, message = "", lid = "", symbol = ""} = {})
+    {
+        // Time
+        const date = new Date();
+        let time = ('0' + date.getHours()).slice(-2) + ":" + ('0' + date.getMinutes()).slice(-2) + ":" + ('0' + date.getSeconds()).slice(-2);
+
+        // Display content in columns
+        time = this.truncateMessage(time, {fit: 7});
+        contextName = this.truncateMessage(contextName, {fit: this.options.contextLenMax, align: AnaLogger.ALIGN.RIGHT});
+        // id = this.truncateMessage(id, {fit: this.options.idLenMax})
+        lid = this.truncateMessage(lid, {fit: this.options.lidLenMax});
+        message = this.truncateMessage(message, {fit: this.options.messageLenMax});
+        symbol = this.truncateMessage(symbol, {fit: this.options.symbolLenMax});
+
+        return `[${time}] ${contextName}: (${lid}) ${symbol} ${message}`
+    }
+
+    onErrorForUserTarget(context, ...args)
+    {
+        this.errorUserTargetHandler(context, ...args);
+    }
+
+    onError(context, ...args)
+    {
+        if (context.target === this.targets.USER)
+        {
+            this.onErrorForUserTarget(context, ...args);
+        }
+    }
+
+    /**
+     * Forward input to real console log
+     * @param args
+     */
+    onDisplayLog(...args)
+    {
+        this.log(...args);
+    }
+
+    /**
+     * Forward input to real console log
+     * @param args
+     */
+    onDisplayError(...args)
+    {
+        this.error(...args);
+    }
+
+    /**
+     * Set log template
+     * @param format
+     */
+    setLogFormat(format)
+    {
+        if (typeof format !== 'function')
+        {
+            console.error(`Invalid parameter for setFormat. It is expecting a function or method.`);
+            return false
+        }
+        this.format = format.bind(this);
+    }
+
+    resetLogFormatter()
+    {
+        this.format = this.originalFormatFunction;
+    }
+
+    setErrorHandler(handler)
+    {
+        this.errorTargetHandler = handler.bind(this);
+    }
+
+    setErrorHandlerForUserTarget(handler)
+    {
+        this.errorUserTargetHandler = handler.bind(this);
+    }
+
+    // ------------------------------------------------
+    // Color
+    // ------------------------------------------------
+
+    // ------------------------------------------------
+    // Log Contexts
+    // ------------------------------------------------
+    isContextValid(context)
+    {
+        if (
+            !(typeof context === 'object' &&
+                !Array.isArray(context) &&
+                context !== null)
+        )
+        {
+            return false
+        }
+        return (context.hasOwnProperty("contextName") && context.hasOwnProperty("target"))
+    }
+
+    generateDefaultContext()
+    {
+        const defaultContext = {
+            name       : "DEFAULT",
+            contextName: "DEFAULT",
+            target     : "ALL",
+            symbol     : "⚡"
+        };
+
+        defaultContext.id = this.logIndex++;
+        defaultContext.color = COLOR_TABLE[1];
+        return defaultContext
+    }
+
+    generateNewContext()
+    {
+        const newContext = this.generateDefaultContext();
+        newContext.color = COLOR_TABLE[(this.indexColor++) % (COLOR_TABLE.length - 3) + 2];
+        newContext.symbol = "";
+        return newContext
+    }
+
+    generateErrorContext()
+    {
+        const errorContext = this.generateDefaultContext();
+        errorContext.color = COLOR_TABLE[0];
+        errorContext.symbol = "v";
+        errorContext.error = true;
+        return errorContext
+    }
+
+    #allegeProperties(entry)
+    {
+        let converted = entry;
+
+        const defaultContext = this.generateNewContext();
+
+        converted = Object.assign({}, defaultContext, converted);
+
+        if (converted.color.toLowerCase().indexOf("rgb") > -1)
+        {
+            converted.color = "#" + rgbHex(converted.color);
+        }
+        else if (converted.color.indexOf("#") === -1)
+        ;
+
+        return converted;
+    }
+
+    /**
+     * Load the context names that should be available to the environment.
+     * They are defined by the user.
+     * @see Context definitions {@link ./example/cjs/contexts-def.cjs}
+     * @param contextTable
+     */
+    setContexts(contextTable)
+    {
+        const arr = Object.keys(contextTable);
+        contextTable["DEFAULT"] = this.contexts["DEFAULT"] = this.generateDefaultContext();
+        contextTable["ERROR"] = this.contexts["ERROR"] = this.generateErrorContext();
+        arr.forEach((key) =>
+        {
+            const contextPassed = contextTable[key] || {};
+            contextPassed.contextName = key;
+            contextPassed.name = key;
+            this.contexts[key] = this.#allegeProperties(contextPassed);
+            contextTable[key] = this.contexts[key];
+        });
+    }
+
+    setTargets(targetTable = {})
+    {
+        this.targets = Object.assign({}, targetTable, {ALL: "ALL", USER: "USER"});
+    }
+
+    setActiveTarget(target)
+    {
+        this.activeTarget = target;
+    }
+
+    isTargetAllowed(target)
+    {
+        if (!target || !this.activeTarget)
+        {
+            return true;
+        }
+
+        if (target === this.targets.ALL)
+        {
+            return true;
+        }
+
+        return this.activeTarget === target;
+    }
+
+
+    // ------------------------------------------------
+    // Logging methods
+    // ------------------------------------------------
+    writeLogToDom(text)
+    {
+        this.$containers = this.$containers || document.querySelectorAll(this.options.logToDom);
+
+        for (let i = 0; i < this.$containers.length; ++i)
+        {
+            const $container = this.$containers[i];
+
+            let $view = $container.querySelector(".analogger-view");
+            if (!$view)
+            {
+                $view = document.createElement("div");
+                $view.classList.add("analogger-view");
+                $container.append($view);
+            }
+
+            const line = document.createElement("div");
+            line.classList.add("to-esm-line");
+            line.textContent = text;
+            const row = document.createElement("span");
+            row.classList.add("to-esm-row");
+            line.append(row);
+
+            $view.append(line);
+        }
+    }
+
+    /**
+     * Display log following template
+     * @param context
+     */
+    processOutput(context = {})
+    {
+        try
+        {
+            if (!this.isTargetAllowed(context.target))
+            {
+                return
+            }
+
+            let args = Array.prototype.slice.call(arguments);
+            args.shift();
+
+            const message = args.join(" | ");
+
+            let output = "";
+            const text = this.format({...context, message});
+
+            if (this.isBrowser())
+            {
+                context.environnment = AnaLogger.ENVIRONMENT_TYPE.BROWSER;
+                if (this.options.logToDom)
+                {
+                    this.writeLogToDom(text);
+                }
+                output = `%c${text}`;
+            }
+            else
+            {
+                context.environnment = AnaLogger.ENVIRONMENT_TYPE.NODE;
+                output = chalk.hex(context.color)(text);
+            }
+
+            if (this.keepLog)
+            {
+                this.logHistory.push(output);
+            }
+
+            if (this.options.hideLog)
+            {
+                return
+            }
+
+            if (this.isBrowser())
+            {
+                this.realConsoleLog(output, `color: ${context.color}`);
+            }
+            else
+            {
+                this.realConsoleLog(output);
+            }
+
+            this.errorTargetHandler(context, args);
+        }
+        catch (e)
+        {
+            console.error(`AnaLogger:`, e.message);
+        }
+    }
+
+    /**
+     * Check that a parameter (should be the first) uses the expected format.
+     * @param options
+     * @returns {boolean}
+     */
+    isExtendedOptionsPassed(options)
+    {
+        if (typeof options !== "object")
+        {
+            return false;
+        }
+
+        return options.hasOwnProperty("context") || options.hasOwnProperty("target");
+    }
+
+    convertToContext(options, defaultContext)
+    {
+        defaultContext = defaultContext || this.generateDefaultContext();
+        options  = options || defaultContext;
+        let context = options;
+        if (options.context && typeof options.context === "object")
+        {
+            const moreOptions = Object.assign({}, options);
+            delete moreOptions.context;
+            context = Object.assign({}, options.context, moreOptions);
+        }
+
+        context = Object.assign({}, defaultContext, context);
+        delete context.context;
+
+        return context
+    }
+
+    /**
+     * console.log with options set on the first parameter to dictate console log behaviours
+     * @param options
+     * @param args
+     */
+    log(options, ...args)
+    {
+        if (!this.isExtendedOptionsPassed(options))
+        {
+            const defaultContext = this.generateDefaultContext();
+            this.processOutput.apply(this, [defaultContext, options, ...args]);
+            return;
+        }
+
+        let context = this.convertToContext(options);
+
+        this.processOutput.apply(this, [context, ...args]);
+    }
+
+    error(options, ...args)
+    {
+        if (this.options.hideError)
+        {
+            return
+        }
+
+        const errorContext = this.generateErrorContext();
+        let context = this.convertToContext(options, errorContext);
+
+        let args0 = Array.prototype.slice.call(arguments);
+        this.log(context, ...args0);
+    }
+
+    overrideError()
+    {
+        if (!this.options.hideHookMessage)
+        {
+            this.realConsoleLog(`AnaLogger: Hook placed on console.error`);
+        }
+        console.error = this.onDisplayError.bind(this);
+    }
+
+    overrideConsole({log = true, info = true, warn = true, error = false} = {})
+    {
+        if (!this.options.hideHookMessage)
+        {
+            this.realConsoleLog(`AnaLogger: Hook placed on console.log`);
+        }
+
+        if (log)
+        {
+            console.log = this.onDisplayLog.bind(this);
+        }
+
+        if (info)
+        {
+            console.info = this.onDisplayLog.bind(this);
+        }
+
+        if (warn)
+        {
+            console.warn = this.onDisplayLog.bind(this);
+        }
+
+        if (error)
+        {
+            this.overrideError();
+        }
+    }
+
+    removeOverrideError()
+    {
+        console.warn = this.realConsoleError;
+    }
+
+    removeOverride({log = true, info = true, warn = true, error = false} = {})
+    {
+        if (log)
+        {
+            console.log = this.realConsoleLog;
+        }
+
+        if (info)
+        {
+            console.info = this.realConsoleInfo;
+        }
+
+        if (warn)
+        {
+            console.warn = this.realConsoleWarn;
+        }
+
+        if (error)
+        {
+            this.removeOverrideError();
+        }
+
+    }
+
+    info(...args)
+    {
+        return this.log(...args)
+    }
+
+    warn(...args)
+    {
+        return this.log(...args)
+    }
+
+    alert(...args)
+    {
+        if (this.isNode())
+        {
+            return this.log(...args)
+        }
+
+        const message = args.join(" | ");
+
+        alert(message);
+    }
+
+    assert(condition, expected = true, ...args)
+    {
+        let result;
+
+        try
+        {
+            if (typeof condition === 'function')
+            {
+                result = condition(...args);
+                if (result !== expected)
+                {
+                    this.error(`Asset failed`);
+                    return false
+                }
+
+                if (this.options.showPassingTests)
+                {
+                    this.log(`SUCCESS: Assert passed`);
+                }
+                return true
+            }
+
+            if (condition !== expected)
+            {
+                this.error(`Assert failed`);
+                return false
+            }
+
+            if (this.options.showPassingTests)
+            {
+                this.log(`SUCCESS: Assert passed`);
+            }
+            return true
+        }
+        catch (e)
+        {
+            this.error(`Unexpected error in assert`);
+        }
+
+        return false;
+    }
+
+}
+
+const anaLogger = new AnaLogger();
+
+export { anaLogger };

package/dist/index.css

@@ -0,0 +1,47 @@
+.analogger {
+  background-color: #462210;
+  border: 4px solid #16122a;
+  box-shadow: 3px 4px 9px 0px rgba(0, 0, 0, 0.75);
+  height: 320px;
+  overflow: hidden;
+  margin: 1rem;
+  padding: 13px 0 0 0;
+  width: 80%;
+  max-height: 300px;
+}
+.analogger .analogger-view {
+  background-color: #0c0c0c;
+  box-sizing: border-box;
+  color: antiquewhite;
+  display: block;
+  font-family: sans-serif;
+  font-size: 12px;
+  line-height: 30px;
+  height: calc(100% - 20px);
+  margin: 20px 0 0 0;
+  padding: 12px;
+  overflow: auto;
+  position: relative;
+  width: 100%;
+}
+.analogger .analogger-view::-webkit-scrollbar-thumb {
+  border: 5px solid transparent;
+  border-radius: 100px;
+  background-color: #514b6e;
+  background-clip: content-box;
+}
+.analogger .analogger-view::-webkit-scrollbar {
+  width: 20px;
+}
+.analogger .analogger-view::-webkit-scrollbar-track {
+  background-color: #382525;
+  border-radius: 100px;
+}
+.analogger .analogger-view::-webkit-scrollbar-thumb {
+  border-radius: 100px;
+  border: 4px solid transparent;
+  background-clip: content-box;
+  background-color: #9f6c53;
+}
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "analogger",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Js Logger",
   "main": "dist/index-cjs.min.cjs",
   "module": "dist/index-esm.min.mjs",
@@ -17,7 +17,7 @@
     "bundle:prod:cjs": "rollup --config rollup-cjs.config.js",
     "bundle:prod:esm": "rollup --config rollup-esm.config.js",
     "bundle:prod": "npm run convert-cjs:esm && npm run convert-cjs:browser && npm run bundle:prod:cjs && npm run bundle:prod:esm",
-    "test": "npm run bundle:prod && nyc mocha --exit --sort",
+    "test": "npm run bundle:prod && nyc mocha --exit --sort --retries 2",
     "server:start": "http-server.cmd -c-1 -s -p 9880 ./ > log.log",
     "manual:check": "http-server.cmd -c-1 -p 9877 -o example/index.html ./ ",
     "manual:test": "concurrently --success first --kill-others \"npm run test\" \"npm run server:start\"",