awesome-logging - npm Package Compare versions

Comparing version 0.0.1-pre-alpha2 to 0.0.1-pre-alpha3

lib/awesome-logger.d.ts

@@ -1,13 +0,19 @@
-import { AwesomeLoggerTextControl } from './models/config/text';
-import { TextObject } from './models/text-object';
-import { ExtractLoggerType } from './types/extract-logger-type';
-import { AwesomeLoggerDefinitions } from './types/logger-definitions';
-import { AwesomeLoggerType } from './types/logger-type';
+import { TextValue } from './models/text-object';
+import { AwesomeLoggerType, LoggerConfig, LoggerReturnType } from './logger/types/logger-type';
+import { AwesomeLoggerBase } from './logger/models/logger-base';
+import { AwesomeLoggerTextControl } from './logger/models/config/text';
+import { AwesomePromptType, PromptConfig, PromptReturnType } from './interaction/types/prompt-type';
 export declare class AwesomeLogger {
     private static activeLogger;
     private static _lastRenderedLines;
-    static logText(text: string | TextObject | TextObject[]): AwesomeLoggerTextControl;
-    static create<T extends AwesomeLoggerType>(type: T, config: Partial<ExtractLoggerType<AwesomeLoggerDefinitions, T>['config']>): ExtractLoggerType<AwesomeLoggerDefinitions, T>['returnValue'];
-    static log<T extends AwesomeLoggerType>(type: T, config: Partial<ExtractLoggerType<AwesomeLoggerDefinitions, T>['config']>): ExtractLoggerType<AwesomeLoggerDefinitions, T>['returnValue'];
-    private static loggerChanged;
+    private static _lastScrollAmount;
+    static maxLinesInTerminal: number;
+    static logText(text: string | TextValue): AwesomeLoggerTextControl;
+    static create<T extends AwesomeLoggerType>(type: T, config?: LoggerConfig<T>): LoggerReturnType<T>;
+    private static visibleLineCount;
+    private static renderScrollWindow;
+    static log<T extends AwesomeLoggerType>(type: T, config: LoggerConfig<T>): LoggerReturnType<T>;
+    static interrupt<T extends AwesomeLoggerType>(type: T, config: LoggerConfig<T>): void;
+    static loggerChanged(calledFrom: AwesomeLoggerBase): void;
+    static prompt<T extends AwesomePromptType>(type: T, config: PromptConfig<T>): PromptReturnType<T>;
 }

lib/awesome-logger.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AwesomeLogger = void 0;
-var multi_logger_1 = require("./logger/multi-logger");
-var progress_logger_1 = require("./logger/progress-logger");
-var text_logger_1 = require("./logger/text-logger");
-var ansi_utils_1 = require("./ansi-utils");
-var string_utils_1 = require("./string-utils");
-var spinner_logger_1 = require("./logger/spinner-logger");
+var text_object_1 = require("./models/text-object");
+var multi_logger_1 = require("./logger/models/multi-logger");
+var progress_logger_1 = require("./logger/models/progress-logger");
+var spinner_logger_1 = require("./logger/models/spinner-logger");
+var text_logger_1 = require("./logger/models/text-logger");
+var ansi_utils_1 = require("./utils/ansi-utils");
+var text_prompt_1 = require("./interaction/models/text-prompt");
+var toggle_prompt_1 = require("./interaction/models/toggle-prompt");
+var checklist_logger_1 = require("./logger/models/checklist-logger");
 var AwesomeLogger = /** @class */ (function () {
@@ -35,2 +38,6 @@ function AwesomeLogger() {
             }
+            case 'checklist': {
+                logger = new checklist_logger_1.AwesomeChecklistLogger(config);
+                break;
+            }
         }
@@ -42,20 +49,63 @@ if (!logger) {
     };
+    AwesomeLogger.visibleLineCount = function (allLines) {
+        return Math.min(allLines.length, this.maxLinesInTerminal);
+    };
+    AwesomeLogger.renderScrollWindow = function (allLines, scrollAmount) {
+        var _a, _b, _c;
+        var preDots = scrollAmount > 0;
+        var postDots = scrollAmount < allLines.length - this.maxLinesInTerminal;
+        var visibleLineCount = this.visibleLineCount(allLines);
+        for (var i = 0; i < visibleLineCount; i++) {
+            if (preDots && i === 0) {
+                process.stdout.write(new text_object_1.TextObject('...', 'GRAY').toLineString((_a = this._lastRenderedLines) === null || _a === void 0 ? void 0 : _a[0]));
+            }
+            else if (postDots && i === visibleLineCount - 1) {
+                process.stdout.write(new text_object_1.TextObject('...', 'GRAY').toLineString((_b = this._lastRenderedLines) === null || _b === void 0 ? void 0 : _b[this._lastRenderedLines.length - 1]));
+            }
+            else {
+                var line = allLines[i + scrollAmount];
+                process.stdout.write(line.toLineString((_c = this._lastRenderedLines) === null || _c === void 0 ? void 0 : _c[i + this._lastScrollAmount]));
+            }
+            ansi_utils_1.INSERT_LINE();
+        }
+        this._lastScrollAmount = scrollAmount;
+    };
     AwesomeLogger.log = function (type, config) {
+        var loggerReturnType = this.create(type, config);
+        var logger = loggerReturnType;
+        var renderedLines = logger.render().allLines();
+        this.renderScrollWindow(renderedLines, logger.scrollAmount);
+        this._lastRenderedLines = renderedLines;
+        this.activeLogger = logger;
+        return loggerReturnType;
+    };
+    AwesomeLogger.interrupt = function (type, config) {
+        var _a;
         var logger = this.create(type, config);
-        var renderedText = logger['render']();
+        var renderedText = logger.render().toLineString();
         var renderedLines = renderedText === null || renderedText === void 0 ? void 0 : renderedText.split(/[\r\n|\n|\r]/g);
-        this._lastRenderedLines = renderedLines;
-        renderedLines === null || renderedLines === void 0 ? void 0 : renderedLines.forEach(function (line) {
-            process.stdout.write(line);
-            console.log();
+        if (!this.activeLogger || !this._lastRenderedLines) {
+            throw new Error('Cannot interrupt if no logger is active');
+        }
+        if (!renderedLines) {
+            return;
+        }
+        var visibleLines = this.visibleLineCount((_a = this._lastRenderedLines) !== null && _a !== void 0 ? _a : []);
+        renderedLines.forEach(function (renderedLine) {
+            ansi_utils_1.MOVE_UP(visibleLines);
+            ansi_utils_1.INSERT_NEW_LINE();
+            process.stdout.write(renderedLine);
+            ansi_utils_1.MOVE_LEFT();
+            ansi_utils_1.MOVE_DOWN(visibleLines);
+            ansi_utils_1.INSERT_LINE();
         });
-        this.activeLogger = logger;
-        return logger;
     };
-    // Does get called from outside
-    AwesomeLogger.loggerChanged = function () {
-        var _a, _b, _c;
+    AwesomeLogger.loggerChanged = function (calledFrom) {
+        var _a, _b, _c, _d;
+        var validCaller = this.activeLogger.canBeCalledFrom(calledFrom);
+        if (!validCaller) {
+            throw new Error('This logger is not active anymore');
+        }
         ansi_utils_1.HIDE_CURSOR();
-        var renderedText = this.activeLogger['render']();
-        var renderedLines = renderedText === null || renderedText === void 0 ? void 0 : renderedText.split(/[\r\n|\n|\r]/g);
+        var renderedLines = this.activeLogger.render().allLines();
         if (!renderedLines) {
@@ -66,25 +116,49 @@ return;
         var newLineCount = (_c = renderedLines.length) !== null && _c !== void 0 ? _c : 0;
-        var moreLines = newLineCount - lastLineCount;
-        if (moreLines > 0) {
-            for (var i = 0; i < moreLines; i++) {
-                ansi_utils_1.INSERT_LINE();
+        var visibleLines = this.visibleLineCount((_d = this._lastRenderedLines) !== null && _d !== void 0 ? _d : []);
+        if (visibleLines < this.maxLinesInTerminal) {
+            var moreLines = newLineCount - lastLineCount;
+            if (moreLines > 0) {
+                for (var i = 0; i < moreLines; i++) {
+                    ansi_utils_1.INSERT_LINE();
+                }
             }
         }
-        var lessLines = lastLineCount - newLineCount;
-        if (lessLines > 0) {
-            ansi_utils_1.MOVE_UP(lessLines);
-            for (var i = 0; i < lessLines; i++) {
-                ansi_utils_1.DELETE_LINE();
+        if (newLineCount < this.maxLinesInTerminal) {
+            var lessLines = lastLineCount - newLineCount;
+            if (lessLines > 0) {
+                ansi_utils_1.MOVE_UP(lessLines);
+                for (var i = 0; i < lessLines; i++) {
+                    ansi_utils_1.DELETE_LINE();
+                }
             }
         }
-        ansi_utils_1.MOVE_UP(newLineCount);
-        var trimmedLines = string_utils_1.StringUtils.trimLines(renderedLines, this._lastRenderedLines);
-        trimmedLines === null || trimmedLines === void 0 ? void 0 : trimmedLines.forEach(function (line) {
-            if (line) {
-                process.stdout.write(line);
+        ansi_utils_1.MOVE_UP(this.visibleLineCount(renderedLines));
+        this.renderScrollWindow(renderedLines, this.activeLogger.scrollAmount);
+        this._lastRenderedLines = renderedLines;
+    };
+    AwesomeLogger.prompt = function (type, config) {
+        var prompt = undefined;
+        switch (type) {
+            case 'text': {
+                prompt = new text_prompt_1.AwesomeTextPromt(config);
+                break;
             }
-            console.log();
-        });
+            case 'toggle': {
+                prompt = new toggle_prompt_1.AwesomeTogglePromt(config);
+                break;
+            }
+        }
+        if (!prompt) {
+            throw new Error("Logger type '" + type + "' not found");
+        }
+        this.activeLogger = prompt;
+        var renderedLines = prompt.render().allLines();
+        this.renderScrollWindow(renderedLines, prompt.scrollAmount);
         this._lastRenderedLines = renderedLines;
+        prompt.init();
+        prompt.waitForUserInput();
+        return prompt;
     };
+    AwesomeLogger._lastScrollAmount = 0;
+    AwesomeLogger.maxLinesInTerminal = 5;
     return AwesomeLogger;
@@ -91,0 +165,0 @@ }());

lib/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var awesome_logger_1 = require("./awesome-logger");
+var checklist_1 = require("./logger/models/config/checklist");
 // AwesomeLogger.log('text', { text: { text: 'awd', color: 'CYAN' } });
@@ -11,48 +12,67 @@ // AwesomeLogger.logText({ text: 'awd', color: 'GREEN' });
 // AwesomeLogger.logText({ text: 'awd', color: 'GREEN' });
-var line = awesome_logger_1.AwesomeLogger.create('text', { text: [{ text: 'awd\nawd2awd3', color: 'GREEN' }] });
-var prog = awesome_logger_1.AwesomeLogger.create('progress', { totalProgress: 100, filledColor: 'GREEN', maxWidth: 100 });
-var spin = awesome_logger_1.AwesomeLogger.create('spinner', { text: ' My text', spinnerDelay: 75, spinnerFrames: ['▄', '■', '▀', '▀', '■'], spinnerColor: 'MAGENTA' });
-var multi = awesome_logger_1.AwesomeLogger.log('multi', { children: [line, prog, spin] });
-setInterval(function () {
-    prog.setProgress(Math.round(Math.random() * 100));
-}, 1000);
-var i = 1;
-setInterval(function () {
-    line.setText("awdNew" + ("\nline" + i).repeat(i));
-    i++;
-    if (i > 5) {
-        i = 0;
-    }
-}, 2000);
-// import { SimpleMultilineLogger } from './complex-logger/simple-multiline-logger';
-// import { SimpleProgressLogger } from './line-logger/progress-logger';
-// import { SimpleLineLogger } from './line-logger/simple-line-logger';
-// import { SimpleSpinnerLogger } from './line-logger/spinner-logger';
-// const a1 = new SimpleLineLogger('');
-// const a2 = new SimpleLineLogger('');
-// const a3 = new SimpleLineLogger('');
-// const p1 = new SimpleProgressLogger({ totalProgress: 100, filledColor: 'GREEN', maxWidth: 100 });
-// const s1 = new SimpleSpinnerLogger({ text: 'My text', spinnerDelay: 100 });
-// const s2 = new SimpleSpinnerLogger({ text: 'My text', spinnerDelay: 100 });
-// const s3 = new SimpleSpinnerLogger({ text: 'My text', spinnerDelay: 100 });
-// const b = new SimpleMultilineLogger([a1, a2, a3, p1, s1, s2, s3]);
+// const line1 = AwesomeLogger.create('text', { text: { text: '1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15', color: 'GREEN' } });
+// const line2 = AwesomeLogger.create('text', { text: { text: 'awd\nawd2awd3', color: 'GREEN' } });
+// const prog1 = AwesomeLogger.create('progress', { totalProgress: 100, filledColor: 'GREEN', maxWidth: 100 });
+// const spin1 = AwesomeLogger.create('spinner', { text: ' My text', spinnerDelay: 75, spinnerFrames: ['▄', '■', '▀', '▀', '■'], spinnerColor: 'MAGENTA' });
+// const line2 = AwesomeLogger.create('text', { text: [{ text: 'awd\nawd2awd3', color: 'GREEN' }] });
+// const prog2 = AwesomeLogger.create('progress', { totalProgress: 100, filledColor: 'GREEN', maxWidth: 100 });
+// const spin2 = AwesomeLogger.create('spinner', { text: ' My text', spinnerDelay: 75, spinnerFrames: ['▄', '■', '▀', '▀', '■'], spinnerColor: 'MAGENTA' });
+// const multi1 = AwesomeLogger.log('multi', { children: [line1, line2, prog1, spin1] });
+// const multi2 = AwesomeLogger.create('multi', { children: [line2, prog2, spin2] });
+// const multi = AwesomeLogger.log('multi', { children: [multi1, multi2] });
+// line2.setText('\n\n\n\n\ntest');
 // setInterval(() => {
-//   a1.setNextText('val1: ' + Math.random())
-//   a2.setNextText({ text: 'val2: ' + Math.random(), color: "MAGENTA" })
-//   a3.setNextText({ text: 'val3: ' + Math.random() + '\nyeee\nbla', color: "CYAN" });
-//   p1.setProgress(Math.round(Math.random() * 100));
-// }, 300);
+//   prog1.setProgress(Math.round(Math.random() * 100));
+//   // prog2.setProgress(Math.round(Math.random() * 100));
+// }, 1000);
+// let i = 1;
 // setInterval(() => {
-//   const i = new SimpleLineLogger({ text: 'yeee1\nyeee2\nyeee3', color: 'YELLOW' })
-//   b.interrupt(i);
-// }, 1000);
-// setTimeout(() => {
-//   s1.complete({ deleteLine: true });
+//   line1.setText(`awdNew${`\nline${i}`.repeat(i)}`);
+//   i++;
+//   if (i > 5) {
+//     i = 0;
+//   }
 // }, 2000);
-// setTimeout(() => {
-//   s2.complete({ deleteLine: true });
+// let i2 = 1;
+// setInterval(() => {
+//   line2.setText(`awdNew${`\nline${i2}`.repeat(i2)}`);
+//   i2++;
+//   if (i2 > 5) {
+//     i2 = 0;
+//   }
 // }, 3000);
-// setTimeout(() => {
-//   s3.complete({ deleteLine: true });
-// }, 4000);
+// let i3 = 0;
+// setInterval(() => {
+//   AwesomeLogger.interrupt('text', { text: { text: `bla${i3}`, color: 'RED' } });
+//   i3++;
+// }, 5000);
+// AwesomeLogger.prompt('text', { text: 'yeeeeeeeeeee', autoComplete: ['yeeeeee', 'awdware', 'nice story'], fuzzyAutoComplete: true });
+// const a = AwesomeLogger.prompt('toggle', {
+//   options: [
+//     'first', 'second', 'third', 'fourth', 'fifth', 'sixth',
+//     'first', 'second', 'third', 'fourth', 'fifth', 'sixth',
+//     'first', 'second']
+// });
+// a.result.then(x => {
+//   console.log(x[0]);
+// });
+var checklistLogger = awesome_logger_1.AwesomeLogger.log('checklist', {
+    items: [
+        {
+            state: checklist_1.AwesomeChecklistLoggerState.pending,
+            text: 'yeeeee1'
+        },
+        {
+            state: checklist_1.AwesomeChecklistLoggerState.pending,
+            text: 'yeeeee2'
+        },
+        {
+            state: checklist_1.AwesomeChecklistLoggerState.pending,
+            text: 'yeeeee3'
+        }
+    ]
+});
+setInterval(function () {
+    checklistLogger.changeState(Math.round(Math.random() * 2), Math.round(Math.random() * 6));
+}, 100);
 //# sourceMappingURL=index.js.map

lib/logger/multi-logger.d.ts

@@ -8,4 +8,5 @@ import { TextObject } from '../models/text-object';
     hasChanges(): boolean;
+    canBeCalledFrom(calledFrom: AwesomeLoggerBase): boolean;
     getChild<T extends AwesomeLoggerBase>(index: number): T;
     getNextLine(): string | TextObject | TextObject[];
 }

lib/logger/multi-logger.js

@@ -29,2 +29,5 @@ "use strict";
     };
+    AwesomeMultiLogger.prototype.canBeCalledFrom = function (calledFrom) {
+        return (calledFrom === this || this._children.some(function (x) { return x.canBeCalledFrom(calledFrom); }));
+    };
     AwesomeMultiLogger.prototype.getChild = function (index) {
@@ -31,0 +34,0 @@ return this._children[index];

lib/logger/progress-logger.d.ts

@@ -9,4 +9,5 @@ import { TextObject } from '../models/text-object';
     hasChanges(): boolean;
+    canBeCalledFrom(calledFrom: AwesomeLoggerBase): boolean;
     getNextLine(): string | TextObject | TextObject[];
     setProgress(progress: number): void;
 }

lib/logger/progress-logger.js

@@ -41,2 +41,5 @@ "use strict";
     };
+    AwesomeProgressLogger.prototype.canBeCalledFrom = function (calledFrom) {
+        return calledFrom === this;
+    };
     AwesomeProgressLogger.prototype.getNextLine = function () {
@@ -43,0 +46,0 @@ var totalLength = Math.min(process.stdout.columns - 2, this._options.maxWidth);

lib/logger/spinner-logger.d.ts

@@ -10,4 +10,5 @@ import { AwesomeLoggerSpinnerConfig } from '../models/config/spinner';
     hasChanges(): boolean;
+    canBeCalledFrom(calledFrom: AwesomeLoggerBase): boolean;
     getNextLine(): string | TextObject | TextObject[];
     complete(options: any): void;
 }

lib/logger/spinner-logger.js

@@ -50,2 +50,5 @@ "use strict";
     };
+    AwesomeSpinnerLogger.prototype.canBeCalledFrom = function (calledFrom) {
+        return calledFrom === this;
+    };
     AwesomeSpinnerLogger.prototype.getNextLine = function () {
@@ -52,0 +55,0 @@ return __spreadArrays([

lib/logger/text-logger.d.ts

@@ -8,4 +8,5 @@ import { TextObject } from '../models/text-object';
     hasChanges(): boolean;
+    canBeCalledFrom(calledFrom: AwesomeLoggerBase): boolean;
     getNextLine(): string | TextObject | TextObject[];
     setText(text: string | TextObject | TextObject[]): void;
 }

lib/logger/text-logger.js

@@ -29,2 +29,5 @@ "use strict";
     };
+    AwesomeTextLogger.prototype.canBeCalledFrom = function (calledFrom) {
+        return calledFrom === this;
+    };
     AwesomeTextLogger.prototype.getNextLine = function () {
@@ -31,0 +34,0 @@ return this._text;

lib/models/logger-base.d.ts

@@ -8,2 +8,3 @@ import { TextObject } from './text-object';
     abstract hasChanges(): boolean;
+    abstract canBeCalledFrom(calledFrom: AwesomeLoggerBase): boolean;
     protected changed(): void;
@@ -10,0 +11,0 @@ getLine(): string | TextObject | TextObject[];

lib/models/logger-base.js

@@ -13,3 +13,3 @@ "use strict";
         this._hasChanges = true;
-        awesome_logger_1.AwesomeLogger['loggerChanged']();
+        awesome_logger_1.AwesomeLogger.loggerChanged(this);
     };
@@ -16,0 +16,0 @@ AwesomeLoggerBase.prototype.getLine = function () {

lib/models/text-object.d.ts

 import { AwesomeLoggerColor } from '../types/logger-color';
-export declare class TextObject {
+export interface TextValue {
     text: string;
     color?: AwesomeLoggerColor;
-    static ensureString(line: string | TextObject | TextObject[]): string;
-    static lineWidth(line: string | TextObject | TextObject[]): number;
-    static ensureArray(text: string | TextObject | TextObject[]): TextObject[];
-    static lineCount(text: string | TextObject | TextObject[]): number;
-    static ensureObject(text: string | TextObject): TextObject;
+    bgColor?: AwesomeLoggerColor;
 }
+export declare class TextObject {
+    private readonly _values;
+    private _child?;
+    constructor(text: string, color?: AwesomeLoggerColor, bgColor?: AwesomeLoggerColor);
+    static create(text: string | TextObject | TextValue): TextObject;
+    static ensureTextValue(text: string | TextValue): TextValue;
+    append(textObject: TextObject): TextObject;
+    append(text: string, color?: AwesomeLoggerColor, bgColor?: AwesomeLoggerColor): TextObject;
+    appendLine(child: TextObject): TextObject;
+    toLineString(lastText?: TextObject): string;
+    static calculateLastChangedCharacterIndex(oldText: TextObject, newText: TextObject): number;
+    private findIndices;
+    getColorAt(i: number): AwesomeLoggerColor | undefined;
+    getBgColorAt(i: number): AwesomeLoggerColor | undefined;
+    getCharAt(i: number): string | undefined;
+    get length(): number;
+    toString(): string;
+    width(): number;
+    hasNextLine(): boolean;
+    nextLine(): TextObject | undefined;
+    allLines(): TextObject[];
+}

lib/models/text-object.js

@@ -7,40 +7,157 @@ "use strict";
 exports.TextObject = void 0;
+var slice_ansi_1 = __importDefault(require("slice-ansi"));
 var string_width_1 = __importDefault(require("string-width"));
 var logger_color_1 = require("../types/logger-color");
 var TextObject = /** @class */ (function () {
-    function TextObject() {
+    function TextObject(text, color, bgColor) {
+        var _a;
+        var lines = text.split(/[\r\n]/g).filter(function (x) { return !!x; });
+        var firstLine = (_a = lines.splice(0, 1)[0]) !== null && _a !== void 0 ? _a : '';
+        this._values = [{ text: firstLine, color: color, bgColor: bgColor }];
+        if (lines.length > 0) {
+            this._child = new TextObject(lines.join('\n'), color, bgColor);
+        }
     }
-    TextObject.ensureString = function (line) {
-        var isArray = Array.isArray(line);
-        var isObj = typeof line === 'object';
-        if (!isObj && !isArray) {
-            return line;
+    TextObject.create = function (text) {
+        if (typeof text === 'string') {
+            return new TextObject(text);
         }
-        var lineObjArray = isArray ? line : [line];
-        return lineObjArray.map(function (x) { return logger_color_1.colorize(x.color)(x.text); }).join('');
+        if (text instanceof TextObject) {
+            return text;
+        }
+        return new TextObject(text.text, text.color, text.bgColor);
     };
-    TextObject.lineWidth = function (line) {
-        var lineStr = this.ensureString(line);
-        return string_width_1.default(lineStr);
+    TextObject.ensureTextValue = function (text) {
+        if (typeof text === 'string') {
+            return { text: text };
+        }
+        return { text: text.text, color: text.color, bgColor: text.bgColor };
     };
-    TextObject.ensureArray = function (text) {
-        var isObj = typeof text === 'object';
-        var isArray = Array.isArray(text);
-        if (!isObj && !isArray) {
-            return [{ text: text }];
+    TextObject.prototype.append = function (text, color, bgColor) {
+        var _this = this;
+        if (typeof text === 'string') {
+            this._values.push({ text: text, color: color, bgColor: bgColor });
         }
-        var lineObjArray = isArray ? text : [text];
-        return lineObjArray;
+        else {
+            text === null || text === void 0 ? void 0 : text._values.forEach(function (v) {
+                _this._values.push({ text: v.text, color: v.color, bgColor: v.bgColor });
+            });
+            if (text === null || text === void 0 ? void 0 : text._child) {
+                var parent_1 = this;
+                var child = this._child;
+                while (child) {
+                    parent_1 = child;
+                    child = parent_1._child;
+                }
+                parent_1._child = text._child;
+            }
+        }
+        return this;
     };
-    TextObject.lineCount = function (text) {
-        var str = this.ensureString(text);
-        return str.split(/\r\n|\r|\n/).length;
+    TextObject.prototype.appendLine = function (child) {
+        this._child = child;
+        return this._child;
     };
-    TextObject.ensureObject = function (text) {
-        var isObj = typeof text === 'object';
-        if (!isObj) {
-            return { text: text };
+    TextObject.prototype.toLineString = function (lastText) {
+        var appendSpaces = '';
+        var textLength = this.length;
+        var newTextRenderLength = textLength;
+        if (lastText) {
+            var lastlength = lastText.length;
+            if (lastlength > textLength) {
+                appendSpaces = ' '.repeat(lastlength - textLength);
+            }
+            else if (lastlength === textLength) {
+                newTextRenderLength = TextObject.calculateLastChangedCharacterIndex(lastText, this) + 1;
+            }
         }
-        return text;
+        var res = '';
+        res += this._values.map(function (x) { return logger_color_1.colorize(x.color, x.bgColor)(x.text); }).join('');
+        var changedText = (newTextRenderLength !== -1 ? slice_ansi_1.default(res, 0, newTextRenderLength) : res) + appendSpaces;
+        return changedText;
     };
+    TextObject.calculateLastChangedCharacterIndex = function (oldText, newText) {
+        var lastChangeAt = -1;
+        for (var i = 0; i < oldText.length; i++) {
+            var oldChar = oldText.getCharAt(i);
+            var newChar = newText.getCharAt(i);
+            var oldColor = oldText.getColorAt(i);
+            var newColor = newText.getColorAt(i);
+            var oldColorBg = oldText.getBgColorAt(i);
+            var newColorBg = newText.getBgColorAt(i);
+            if (oldChar !== newChar || oldColor !== newColor || oldColorBg !== newColorBg) {
+                lastChangeAt = i;
+            }
+        }
+        return lastChangeAt;
+    };
+    TextObject.prototype.findIndices = function (i) {
+        var counter = i;
+        var valuesIndex = 0;
+        var valuesArrValue = this._values[0];
+        while (valuesArrValue.text.length < counter + 1) {
+            counter -= valuesArrValue.text.length;
+            valuesIndex++;
+            valuesArrValue = this._values[valuesIndex];
+            if (!valuesArrValue) {
+                return [-1, -1];
+            }
+        }
+        return [valuesIndex, counter];
+    };
+    TextObject.prototype.getColorAt = function (i) {
+        var valueIndex = this.findIndices(i)[0];
+        if (valueIndex === -1) {
+            return undefined;
+        }
+        return this._values[valueIndex].color;
+    };
+    TextObject.prototype.getBgColorAt = function (i) {
+        var valueIndex = this.findIndices(i)[0];
+        if (valueIndex === -1) {
+            return undefined;
+        }
+        return this._values[valueIndex].bgColor;
+    };
+    TextObject.prototype.getCharAt = function (i) {
+        var _a = this.findIndices(i), valueIndex = _a[0], charIndex = _a[1];
+        if (valueIndex === -1 || charIndex === -1) {
+            return undefined;
+        }
+        return this._values[valueIndex].text[charIndex];
+    };
+    Object.defineProperty(TextObject.prototype, "length", {
+        get: function () {
+            return this._values.map(function (x) { return string_width_1.default(x.text); }).reduce(function (a, b) { return a + b; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextObject.prototype.toString = function () {
+        var res = '';
+        res += this._values.map(function (x) { return logger_color_1.colorize(x.color, x.bgColor)(x.text); }).join('');
+        if (this._child) {
+            res += "\n" + this._child.toString();
+        }
+        return res;
+    };
+    TextObject.prototype.width = function () {
+        var lineStr = this.toLineString();
+        return string_width_1.default(lineStr);
+    };
+    TextObject.prototype.hasNextLine = function () {
+        return !!this._child;
+    };
+    TextObject.prototype.nextLine = function () {
+        return this._child;
+    };
+    TextObject.prototype.allLines = function () {
+        var nextLine = this;
+        var allLines = [nextLine];
+        while (nextLine.hasNextLine()) {
+            nextLine = nextLine.nextLine();
+            allLines.push(nextLine);
+        }
+        return allLines;
+    };
     return TextObject;
@@ -47,0 +164,0 @@ }());

lib/types/extract-logger-type.d.ts

@@ -0,3 +1,6 @@
+import { AwesomeLoggerDefinitions } from './logger-definitions';
 export declare type ExtractLoggerType<A, T> = A extends {
     type: T;
 } ? A : never;
+export declare type LoggerConfig<T> = Partial<ExtractLoggerType<AwesomeLoggerDefinitions, T>['config']>;
+export declare type LoggerReturnType<T> = ExtractLoggerType<AwesomeLoggerDefinitions, T>['returnValue'];

lib/types/logger-color.d.ts

 import chalk from 'chalk';
 export declare type AwesomeLoggerColor = 'WHITE' | 'BLACK' | 'RED' | 'GREEN' | 'YELLOW' | 'BLUE' | 'MAGENTA' | 'CYAN' | 'GRAY';
-export declare const colorize: (color?: "WHITE" | "BLACK" | "RED" | "GREEN" | "YELLOW" | "BLUE" | "MAGENTA" | "CYAN" | "GRAY" | undefined) => chalk.Chalk;
+export declare const colorizeFg: (color?: "WHITE" | "BLACK" | "RED" | "GREEN" | "YELLOW" | "BLUE" | "MAGENTA" | "CYAN" | "GRAY" | undefined) => chalk.Chalk | ((a: any) => any);
+export declare const colorize: (color?: "WHITE" | "BLACK" | "RED" | "GREEN" | "YELLOW" | "BLUE" | "MAGENTA" | "CYAN" | "GRAY" | undefined, bgColor?: "WHITE" | "BLACK" | "RED" | "GREEN" | "YELLOW" | "BLUE" | "MAGENTA" | "CYAN" | "GRAY" | undefined) => (str: string) => any;

lib/types/logger-color.js

@@ -6,5 +6,19 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorize = void 0;
+exports.colorize = exports.colorizeFg = void 0;
 var chalk_1 = __importDefault(require("chalk"));
-exports.colorize = function (color) {
+var colorizeBg = function (bgColor) {
+    switch (bgColor) {
+        case 'WHITE': return chalk_1.default.bgWhite;
+        case 'BLACK': return chalk_1.default.bgBlack;
+        case 'RED': return chalk_1.default.bgRed;
+        case 'GREEN': return chalk_1.default.bgGreen;
+        case 'YELLOW': return chalk_1.default.bgYellow;
+        case 'BLUE': return chalk_1.default.bgBlue;
+        case 'MAGENTA': return chalk_1.default.bgMagenta;
+        case 'CYAN': return chalk_1.default.bgCyan;
+        case 'GRAY': return chalk_1.default.bgGray;
+        default: return function (a) { return a; };
+    }
+};
+var colorizeFg = function (color) {
     switch (color) {
@@ -20,5 +34,10 @@ case 'WHITE': return chalk_1.default.white;
         case 'GRAY': return chalk_1.default.gray;
-        default: return chalk_1.default.white;
+        default: return function (a) { return a; };
     }
 };
+exports.colorizeFg = colorizeFg;
+var colorize = function (color, bgColor) {
+    return function (str) { return exports.colorizeFg(color)(colorizeBg(bgColor)(str)); };
+};
+exports.colorize = colorize;
 //# sourceMappingURL=logger-color.js.map

lib/types/logger-type.d.ts

 import { AwesomeLoggerDefinitions } from './logger-definitions';
+export declare type ExtractLoggerType<A, T> = A extends {
+    type: T;
+} ? A : never;
+export declare type LoggerConfig<T> = Partial<ExtractLoggerType<AwesomeLoggerDefinitions, T>['config']>;
+export declare type LoggerReturnType<T> = ExtractLoggerType<AwesomeLoggerDefinitions, T>['returnValue'];
 export declare type AwesomeLoggerType = AwesomeLoggerDefinitions['type'];

package.json

 {
   "name": "awesome-logging",
-  "version": "0.0.1-pre-alpha2",
+  "version": "0.0.1-pre-alpha3",
   "description": "Advanced logging messages, interactive prompts, loading animations and more in TypeScript",
@@ -19,2 +19,3 @@ "main": "lib/index.js",
     "cli-truncate": "^2.1.0",
+    "restore-cursor": "^3.1.0",
     "slice-ansi": "^4.0.0",
@@ -33,3 +34,3 @@ "string-width": "^4.2.0",
     "ts-node": "^9.0.0",
-    "typescript": "^4.0.5"
+    "typescript": "^4.1.2"
   },
@@ -36,0 +37,0 @@ "keywords": [

No alert changes

Improved metrics

Total package byte prevSize

193942

106.83%

Number of package files

176

74.26%

Lines of code

2770

102.34%

Worsened metrics

Dependency count

6

20%

Dependency changes

• + Added

  restore-cursor@^3.1.0

• + Added

  mimic-fn@2.1.0
  (transitive)

• + Added

  onetime@5.1.2
  (transitive)

• + Added

  restore-cursor@3.1.0
  (transitive)

• + Added

  signal-exit@3.0.7
  (transitive)