@webtypen/webframez-core 0.1.3 → 0.1.5

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,79 @@ 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 new Promise((resolve) => {
+            if (this.rl) {
+                this.rl.question(question, (answer) => {
+                    resolve(answer);
+                });
+            }
+            resolve(null);
+        });
+    }
+    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/dist/Router/Request.d.ts

@@ -9,6 +9,7 @@ export declare class Request {
     body: any;
     bodyPlain: any;
     query: any;
+    queryRaw: any;
     params: any;
     files: any;
     socket: any;

package/dist/Router/Request.js

@@ -10,6 +10,7 @@ class Request {
         this.body = null;
         this.bodyPlain = null;
         this.query = {};
+        this.queryRaw = "";
         this.params = {};
         this.files = {};
         this.socket = undefined;

package/dist/Router/Router.js

@@ -285,6 +285,8 @@ class RouterFacade {
             else if (req && req instanceof http_1.IncomingMessage) {
                 const parsedBody = yield this.parseRequestBody(req);
                 const parsedUrl = req.url ? url_1.default.parse(req.url) : null;
+                const searchParams = parsedUrl && parsedUrl.query ? new URLSearchParams(parsedUrl.query) : null;
+                const queryParams = searchParams ? Object.fromEntries(searchParams.entries()) : {};
                 request.message = req;
                 request.bodyPlain = parsedBody ? parsedBody.plain : "";
                 request.body = parsedBody ? parsedBody.parsed : {};
@@ -293,7 +295,8 @@ class RouterFacade {
                 request.url = req.url ? req.url : "";
                 request.method = req.method ? req.method : "";
                 request.socket = req.socket;
-                request.query = parsedUrl ? parsedUrl.query : {};
+                request.query = queryParams;
+                request.queryRaw = parsedUrl && parsedUrl.query ? parsedUrl.query : "";
                 request.pathname = parsedUrl ? parsedUrl.pathname : "";
             }
             return request;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.1.3",
+    "version": "0.1.5",
     "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,77 @@
+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;
+    }
+
+    ask(question: string) {
+        return new Promise((resolve) => {
+            if (this.rl) {
+                this.rl.question(question, (answer) => {
+                    resolve(answer);
+                });
+            }
+            resolve(null);
+        });
+    }
+
+    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);
     }

package/src/Router/Request.ts

@@ -9,6 +9,7 @@ export class Request {
     body: any = null;
     bodyPlain: any = null;
     query: any = {};
+    queryRaw: any = "";
     params: any = {};
     files: any = {};
     socket: any = undefined;

package/src/Router/Router.ts

@@ -322,6 +322,8 @@ class RouterFacade {
         } else if (req && req instanceof IncomingMessage) {
             const parsedBody: any = await this.parseRequestBody(req);
             const parsedUrl = req.url ? url.parse(req.url) : null;
+            const searchParams = parsedUrl && parsedUrl.query ? new URLSearchParams(parsedUrl.query) : null;
+            const queryParams = searchParams ? Object.fromEntries(searchParams.entries()) : {};
 
             request.message = req;
             request.bodyPlain = parsedBody ? parsedBody.plain : "";
@@ -331,7 +333,8 @@ class RouterFacade {
             request.url = req.url ? req.url : "";
             request.method = req.method ? req.method : "";
             request.socket = req.socket;
-            request.query = parsedUrl ? parsedUrl.query : {};
+            request.query = queryParams;
+            request.queryRaw = parsedUrl && parsedUrl.query ? parsedUrl.query : "";
             request.pathname = parsedUrl ? parsedUrl.pathname : "";
         }
         return request;