@webtypen/webframez-core 0.1.4 → 0.1.6

package/dist/Commands/ConsoleCommand.d.ts

@@ -1,5 +1,19 @@
+/// <reference types="node" />
+import readline from "readline";
+import { ConsoleProgressBar } from "./ConsoleProgressBar";
 export declare class ConsoleCommand {
     static signature: string;
     static description?: string;
+    rl: readline.Interface | null;
+    currentProgress: ConsoleProgressBar | null;
+    constructor();
     handle(): Promise<void>;
+    handleSystem(): Promise<void>;
+    finallySystem(): Promise<void>;
+    write(message: string): this;
+    writeln(message: string): this;
+    ask(question: string): Promise<unknown>;
+    progress(count: number): this;
+    progressIncrement(): this;
+    progressFinish(): this;
 }

package/dist/Commands/ConsoleCommand.js

@@ -8,11 +8,82 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleCommand = void 0;
+const os_1 = __importDefault(require("os"));
+const readline_1 = __importDefault(require("readline"));
+const ConsoleProgressBar_1 = require("./ConsoleProgressBar");
 class ConsoleCommand {
+    constructor() {
+        this.currentProgress = null;
+        this.rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+    }
     handle() {
         return __awaiter(this, void 0, void 0, function* () { });
     }
+    handleSystem() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.handle();
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                yield this.finallySystem();
+            }
+        });
+    }
+    finallySystem() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.rl) {
+                this.rl.close();
+            }
+        });
+    }
+    write(message) {
+        process.stdout.write(message);
+        return this;
+    }
+    writeln(message) {
+        process.stdout.write(message + os_1.default.EOL);
+        return this;
+    }
+    ask(question) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield new Promise((resolve) => {
+                if (this.rl) {
+                    this.rl.question(question, (answer) => {
+                        resolve(answer);
+                    });
+                }
+                resolve(null);
+            });
+            return result;
+        });
+    }
+    progress(count) {
+        this.currentProgress = new ConsoleProgressBar_1.ConsoleProgressBar(count);
+        this.currentProgress.render();
+        return this;
+    }
+    progressIncrement() {
+        if (this.currentProgress) {
+            this.currentProgress.increment();
+        }
+        return this;
+    }
+    progressFinish() {
+        if (this.currentProgress) {
+            this.currentProgress.finish();
+        }
+        return this;
+    }
 }
 exports.ConsoleCommand = ConsoleCommand;

package/dist/Commands/ConsoleProgressBar.d.ts

@@ -0,0 +1,10 @@
+export declare class ConsoleProgressBar {
+    total: number;
+    current: number;
+    barLength: number;
+    constructor(total: number);
+    update(current: number): void;
+    finish(): void;
+    render(): void;
+    increment(): void;
+}

package/dist/Commands/ConsoleProgressBar.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleProgressBar = void 0;
+const os_1 = __importDefault(require("os"));
+class ConsoleProgressBar {
+    constructor(total) {
+        this.total = 0;
+        this.current = 0;
+        this.barLength = 40;
+        this.total = total;
+        this.current = 0;
+        this.barLength = 40; // Länge der Fortschrittsanzeige in Zeichen
+    }
+    update(current) {
+        this.current = current;
+        this.render();
+    }
+    finish() {
+        const progressText = "█".repeat(this.barLength);
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(`Progress: [${progressText}] | 100%` + os_1.default.EOL);
+    }
+    render() {
+        const percentage = this.current / this.total;
+        const progress = Math.round(this.barLength * percentage);
+        const emptyProgress = this.barLength - progress;
+        const progressText = "█".repeat(progress);
+        const emptyProgressText = "░".repeat(emptyProgress);
+        const percentageText = (percentage * 100).toFixed(2);
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(`Progress: [${progressText}${emptyProgressText}] | ${percentageText}%`);
+    }
+    increment() {
+        this.current += 1;
+        if (this.current > this.total) {
+            this.current = this.total;
+        }
+        this.render();
+    }
+}
+exports.ConsoleProgressBar = ConsoleProgressBar;

package/dist/ConsoleApplication.js

@@ -36,7 +36,7 @@ class ConsoleApplication {
             }
             consoleCommand.action(() => __awaiter(this, void 0, void 0, function* () {
                 const service = yield new command();
-                return yield service.handle();
+                return yield service.handleSystem();
             }));
             program.addCommand(consoleCommand);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",

package/src/Commands/ConsoleCommand.ts

@@ -1,6 +1,78 @@
+import os from "os";
+import readline from "readline";
+import { ConsoleProgressBar } from "./ConsoleProgressBar";
+
 export class ConsoleCommand {
     static signature: string;
     static description?: string;
 
+    rl: readline.Interface | null;
+    currentProgress: ConsoleProgressBar | null = null;
+
+    constructor() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+    }
+
     async handle() {}
+
+    async handleSystem() {
+        try {
+            await this.handle();
+        } catch (e) {
+            console.error(e);
+        } finally {
+            await this.finallySystem();
+        }
+    }
+
+    async finallySystem() {
+        if (this.rl) {
+            this.rl.close();
+        }
+    }
+
+    write(message: string) {
+        process.stdout.write(message);
+        return this;
+    }
+
+    writeln(message: string) {
+        process.stdout.write(message + os.EOL);
+        return this;
+    }
+
+    async ask(question: string) {
+        const result = await new Promise((resolve) => {
+            if (this.rl) {
+                this.rl.question(question, (answer) => {
+                    resolve(answer);
+                });
+            }
+            resolve(null);
+        });
+        return result;
+    }
+
+    progress(count: number) {
+        this.currentProgress = new ConsoleProgressBar(count);
+        this.currentProgress.render();
+        return this;
+    }
+
+    progressIncrement() {
+        if (this.currentProgress) {
+            this.currentProgress.increment();
+        }
+        return this;
+    }
+
+    progressFinish() {
+        if (this.currentProgress) {
+            this.currentProgress.finish();
+        }
+        return this;
+    }
 }

package/src/Commands/ConsoleProgressBar.ts

@@ -0,0 +1,47 @@
+import os from "os";
+
+export class ConsoleProgressBar {
+    total: number = 0;
+    current: number = 0;
+    barLength: number = 40;
+
+    constructor(total: number) {
+        this.total = total;
+        this.current = 0;
+        this.barLength = 40; // Länge der Fortschrittsanzeige in Zeichen
+    }
+
+    update(current: number) {
+        this.current = current;
+        this.render();
+    }
+
+    finish() {
+        const progressText = "█".repeat(this.barLength);
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(`Progress: [${progressText}] | 100%` + os.EOL);
+    }
+
+    render() {
+        const percentage = this.current / this.total;
+        const progress = Math.round(this.barLength * percentage);
+        const emptyProgress = this.barLength - progress;
+
+        const progressText = "█".repeat(progress);
+        const emptyProgressText = "░".repeat(emptyProgress);
+        const percentageText = (percentage * 100).toFixed(2);
+
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(`Progress: [${progressText}${emptyProgressText}] | ${percentageText}%`);
+    }
+
+    increment() {
+        this.current += 1;
+        if (this.current > this.total) {
+            this.current = this.total;
+        }
+        this.render();
+    }
+}

package/src/ConsoleApplication.ts

@@ -28,7 +28,7 @@ export class ConsoleApplication {
       }
       consoleCommand.action(async () => {
         const service = await new command();
-        return await service.handle();
+        return await service.handleSystem();
       });
       program.addCommand(consoleCommand);
     }