@guritso/terminal 1.1.0 → 1.1.2

package/README.md

@@ -1,10 +1,10 @@
 # @guritso/terminal
 
-A terminal node utility for logging and error handling.
+A terminal node utility for enhanced logging and error handling.
 
 | example |
 | ------- |
-| ![example](https://i.ibb.co/sm49x0x/Captura-de-tela-de-2024-09-23-05-59-20.png) |
+| ![example](https://i.ibb.co/WHD4mXn/guritso-terminal-preview.png) |
 
 ## Installation
 
@@ -12,18 +12,23 @@ To install the package:
 
 ```bash
 npm install @guritso/terminal
-# or
-pnpm install @guritso/terminal
-# or
-yarn add @guritso/terminal
 ```
 
 ## Usage
 
 To use the package, import it into your project:
 
+```javascript
+const terminal = require('@guritso/terminal');
+```
+
+or ESM:
+
 ```javascript
 import terminal from '@guritso/terminal';
+```
+
+```javascript
 // Setup the terminal (this is necessary to use the console.error function)
 terminal.setup();
 
@@ -67,14 +72,14 @@ Displays a log message.
 
 ### `terminal.setVerbose(verbose)`
 
-Sets the verbose level. (0 = no output (does't apply for start()), 1 = same line output (does't apply for pass), 2 = new line output)
+Sets the verbose level.
 
 - `verbose` (number): The verbose level.
-
-
-## Methods
+  - `0`: no output (does't apply for `terminal.start()`)
+  - `1`: same line output (does't apply for `terminal.pass()`)
+  - `2`: new line output (default)
 
 ## License
 
-This project is licensed under the GPL-3.0 License. See the [LICENSE](./LICENSE) file for details.
+[MIT License](./LICENSE)
 

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require("./lib/cjs/terminal.cjs");

package/index.d.ts

@@ -0,0 +1,24 @@
+declare module "@guritso/terminal" {
+  export interface Terminal {
+    verbose: number;
+    readonly levels: {
+      readonly info: string;
+      readonly fail: string;
+      readonly pass: string;
+    };
+    projectInfo: {
+      name: string;
+      version: string;
+    };
+    start(host?: string, port?: number): void;
+    pass(message: unknown): void;
+    log(message: unknown): void;
+    setup(): boolean;
+    clear(): boolean;
+    setVerbose(verbose: number): void;
+    isError(data: unknown): boolean;
+  }
+
+  const terminal: Terminal;
+  export = terminal;
+}

package/index.js

@@ -1 +1,3 @@
-module.exports = require('./lib/terminal.js');
+import terminal from "./lib/terminal.js";
+
+export default terminal;

package/lib/cjs/terminal.cjs

@@ -0,0 +1,293 @@
+'use strict';
+
+var url = require('url');
+var fs = require('fs');
+
+/*!
+ * Terminal
+ * Copyright (c) 2024 @GuriTso
+ * @license GPL-3.0
+ */
+
+
+/**
+ * This function is used to colorize the text
+ * @param {string} txt - The text to colorize
+ * @returns {string | any} - The colorized text
+ * @example
+ * color("Hello %H1 World") // "Hello \x1b[1mWorld\x1b[0m"
+ * color("%h1 start here%H nothing here") // "\x1b[1m start here\x1b[0m nothing here"
+ */
+function color(txt) {
+  if (typeof txt !== "string") return txt;
+
+  const arr = txt.split("%H");
+  let res = arr.join("");
+
+  for (const a of arr) {
+    const [n, ...w] = a.split(" ");
+
+    if (!n || !txt.includes(`%H${n}`) || isNaN(n)) continue;
+
+    const mo = `\x1b[${n}m${w.join(" ")}\x1b[0m`;
+
+    res = res.replace(a, mo);
+  }
+  return res;
+}
+/**
+ * Get a list of common error names
+ *
+ * @returns {string[]}
+ */
+function getErrorNames() {
+  return Object.getOwnPropertyNames(global).filter((name) => {
+    try {
+      return (
+        typeof global[name] === "function" &&
+        global[name].prototype instanceof Error
+      );
+    } catch (e) {
+      return false;
+    }
+  });
+}
+/**
+ * Format the URL based on the provided host and port.
+ *
+ * @param {string} host - The host to format.
+ * @param {number} port - The port to format.
+ * @returns {string} - The formatted URL.
+ */
+function formatUrl(host, port) {
+  const locals = ["localhost", "127.0.0.1", "0.0.0.0"];
+
+  try {
+    if (typeof host !== "string") {
+      return new Error("host must be a string");
+    }
+
+    const url$1 = new url.URL(host);
+
+    if (port && port !== url$1.port) {
+      url$1.port = port;
+    }
+
+    if (!url$1.protocol) {
+      url$1.protocol = "http:";
+    } else if (url$1.protocol !== "https:" && url$1.protocol !== "http:") {
+      url$1.protocol = "http:";
+    }
+
+    return { url: url$1.toString(), port: url$1.port };
+  } catch (error) {
+    if (locals.includes(host)) {
+      return formatUrl("http://localhost", port);
+    } else {
+      return error;
+    }
+  }
+}
+
+/*!
+ * Terminal
+ * Copyright (c) 2024 @GuriTso
+ * @license GPL-3.0
+ */
+
+
+/**
+ * @typedef {Object} Terminal
+ * @property {number} verbose
+ * @property {Object} levels
+ * @property {string} levels.info
+ * @property {string} levels.fail
+ * @property {string} levels.pass
+ * @property {function(string, number): void} start
+ * @property {function(string): void} pass
+ * @property {function(string): void} log
+ * @property {function(): void} setup
+ * @property {function(): void} clear
+ * @property {function(number): void} setVerbose
+ * @property {function(any): boolean} isError
+ * @property {Object} projectInfo
+ */
+
+/** @type {Terminal} */
+const terminal = {
+  verbose: 2,
+  levels: {
+    info: color("%H100  INFO:%H"),
+    fail: color("%H41  FAIL:%H"),
+    pass: color("%H42  PASS:%H"),
+  },
+};
+
+const { stdout } = process;
+
+terminal.projectInfo = (() => {
+  try {
+    const { name, version } = JSON.parse(
+      fs.readFileSync("./package.json", "utf-8")
+    );
+
+    return { name, version };
+  } catch (error) {
+    return { name: "unknown", version: "unknown" };
+  }
+})();
+
+/**
+ *  display the project info and host, port
+ *
+ * @param {string} host - The host to display
+ * @param {number} port - The port number to display
+ */
+terminal.start = function start(host, port) {
+  const projectInfo = terminal.projectInfo;
+  const hostInfo = formatUrl(host, port);
+
+  const headLines = [
+    `\n%H46  name:%H%H44  ${projectInfo.name} `,
+    `%H105  version:%H%H41  ${projectInfo.version} %H\n`,
+    hostInfo?.url ? `%H43  host:%H95  ${hostInfo.url}\n` : "",
+    hostInfo?.port ? `%H45  port:%H94  ${hostInfo.port}\n` : "",
+  ];
+
+  for (const line of headLines) {
+    stdout.write(color(line));
+  }
+};
+
+/**
+ *  display successful messages
+ *
+ * @param {string} data
+ */
+terminal.pass = function pass(data) {
+  const { verbose, levels } = terminal;
+
+  if (verbose === 0) return;
+
+  if (typeof data === "object") {
+    // skipcq: JS-0002
+    console.log(color(`\r%H1 ${levels.pass}%H`),data);
+  } else {
+    terminal.clear();
+    stdout.write(color(`\r%H1 ${levels.pass}%H ${String(data)}\n`));
+  }
+};
+
+/**
+ *  display logs messages, error, info, etc.
+ *
+ * @param {any} data
+ */
+terminal.log = function log(data) {
+  const { verbose, levels } = terminal;
+
+  let level = levels.info;
+
+  if (verbose === 0) return;
+
+  if (terminal.isError(data)) {
+    level = levels.fail;
+  }
+
+  if (verbose === 1 && stdout.isTTY) {
+    terminal.clear();
+
+    stdout.write(color(`\r%H1 ${level}%H ${String(data)}`));
+  } else {
+    if (level === terminal.levels.info) {
+      if (typeof data === "object") {
+        // skipcq: JS-0002
+        console.log(color(`%H1 ${level}%H `), data);
+      } else {
+        stdout.write(color(`%H1 ${level}%H ${String(data)}\n`));
+      }
+    } else {
+      // skipcq: JS-0002
+      console.log(color(`%H1 ${level}%H `), data);
+    }
+  }
+};
+
+/**
+ * Check if the data is an error
+ *
+ * @param {any} data
+ * @returns {boolean}
+ */
+terminal.isError = (data) => {
+  if (data instanceof Error) {
+    return true;
+  }
+
+  if (typeof data === "string") {
+    const errorKeywords = getErrorNames().map((name) => name);
+    errorKeywords.push("Error:");
+
+    return errorKeywords.some((keyword) => data.includes(keyword));
+  }
+
+  return false;
+};
+
+/**
+ * Setup the console.error to use the terminal.log function
+ *
+ * @returns {boolean} - true if the setup was successful, false otherwise
+ */
+terminal.setup = () => {
+  if (typeof console === "object" && console.error) {
+    
+    if (typeof console.backup === "function") {
+      return false
+    }
+    
+    // backup the original console.error
+    console.backup = console.error;
+  } else {
+    throw new Error("console.error is not found");
+  }
+
+  // replace the console.error with the terminal.log
+  console.error = terminal.log;
+
+  return true
+};
+
+/**
+ * Clear the terminal
+ */
+terminal.clear = () => {
+  if (stdout.isTTY) {
+    stdout.clearLine();
+    return true
+  }
+
+  return false
+};
+
+/**
+ * Set the verbose level
+ *
+ * @param {number} verbose - The verbose level
+ */
+terminal.setVerbose = (verbose) => {
+  if (!isNaN(Number(verbose))) {
+    const verboseLevel = Number(verbose);
+
+    if (verboseLevel < 0) {
+      terminal.verbose = 0;
+    } else if (verboseLevel > 2) {
+      terminal.verbose = 2;
+    } else {
+      terminal.verbose = verboseLevel;
+    }
+  }
+
+};
+
+module.exports = terminal;

package/lib/terminal.js

@@ -6,10 +6,8 @@
 
 "use strict";
 
-const getErrorNames = require("./utils").getErrorNames;
-const formatUrl = require("./utils").formatUrl;
-const co = require("./utils").color;
-const { readFileSync } = require("fs");
+import { color as co, getErrorNames, formatUrl } from "./utils.js";
+import { readFileSync } from "fs";
 
 /**
  * @typedef {Object} Terminal
@@ -53,7 +51,7 @@ terminal.projectInfo = (() => {
 })();
 
 /**
- *  display the project info and the port
+ *  display the project info and host, port
  *
  * @param {string} host - The host to display
  * @param {number} port - The port number to display
@@ -75,48 +73,55 @@ terminal.start = function start(host, port) {
 };
 
 /**
- *  display the online message
+ *  display successful messages
  *
  * @param {string} data
  */
 terminal.pass = function pass(data) {
-  terminal.clear();
-  stdout.write(co(`\r%H1 ${terminal.levels.pass}%H ${data}\n`));
+  const { verbose, levels } = terminal;
+
+  if (verbose === 0) return;
+
+  if (typeof data === "object") {
+    // skipcq: JS-0002
+    console.log(co(`\r%H1 ${levels.pass}%H`),data);
+  } else {
+    terminal.clear();
+    stdout.write(co(`\r%H1 ${levels.pass}%H ${String(data)}\n`));
+  }
 };
 
 /**
- *  display logs messages
+ *  display logs messages, error, info, etc.
  *
- * @param {string} data
+ * @param {any} data
  */
 terminal.log = function log(data) {
   const { verbose, levels } = terminal;
 
   let level = levels.info;
 
-  if (Number(verbose) === 0) return;
+  if (verbose === 0) return;
 
   if (terminal.isError(data)) {
     level = levels.fail;
   }
 
-  if (Number(verbose) === 1 && stdout.isTTY) {
+  if (verbose === 1 && stdout.isTTY) {
     terminal.clear();
 
-    stdout.write(co(`\r%H1 ${level}%H ${data}`));
+    stdout.write(co(`\r%H1 ${level}%H ${String(data)}`));
   } else {
-    stdout.write(co(`%H1 ${level}%H `));
-
     if (level === terminal.levels.info) {
       if (typeof data === "object") {
         // skipcq: JS-0002
-        console.log(data);
+        console.log(co(`%H1 ${level}%H `), data);
       } else {
-        stdout.write(`${co(data)}\n`);
+        stdout.write(co(`%H1 ${level}%H ${String(data)}\n`));
       }
     } else {
       // skipcq: JS-0002
-      console.log(data);
+      console.log(co(`%H1 ${level}%H `), data);
     }
   }
 };
@@ -133,7 +138,7 @@ terminal.isError = (data) => {
   }
 
   if (typeof data === "string") {
-    const errorKeywords = getErrorNames().map((name) => `Error: ${name}`);
+    const errorKeywords = getErrorNames().map((name) => name);
     errorKeywords.push("Error:");
 
     return errorKeywords.some((keyword) => data.includes(keyword));
@@ -184,7 +189,18 @@ terminal.clear = () => {
  * @param {number} verbose - The verbose level
  */
 terminal.setVerbose = (verbose) => {
-  terminal.verbose = verbose;
+  if (!isNaN(Number(verbose))) {
+    const verboseLevel = Number(verbose);
+
+    if (verboseLevel < 0) {
+      terminal.verbose = 0;
+    } else if (verboseLevel > 2) {
+      terminal.verbose = 2;
+    } else {
+      terminal.verbose = verboseLevel;
+    }
+  }
+
 };
 
-module.exports = terminal;
+export default terminal;

package/lib/utils.js

@@ -4,7 +4,7 @@
  * @license GPL-3.0
  */
 
-const { URL } = require("url");
+import { URL } from "url";
 
 /**
  * This function is used to colorize the text
@@ -80,14 +80,11 @@ function formatUrl(host, port) {
     return { url: url.toString(), port: url.port };
   } catch (error) {
     if (locals.includes(host)) {
-      return formatUrl(`http://${host}`, port);
+      return formatUrl("http://localhost", port);
     } else {
       return error;
     }
   }
 };
 
-exports.color = color;
-exports.getErrorNames = getErrorNames;
-exports.formatUrl = formatUrl;
-
+export { color, getErrorNames, formatUrl };

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@guritso/terminal",
-  "description": "A terminal node utility for logging and error handling",
-  "version": "1.1.0",
+  "description": "A terminal node utility for enhanced logging and error handling",
+  "version": "1.1.2",
   "main": "index.cjs",
   "module": "index.js",
-  "license": "GPL-3.0",
+  "types": "index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs"
+    }
+  },
+  "license": "MIT",
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "build": "rollup -c"
   },
   "repository": {
     "type": "git",
@@ -17,11 +26,13 @@
     "logging",
     "error-handling",
     "cli",
-    "utility"
+    "utility",
+    "backend"
   ],
   "author": "GuriTso",
   "devDependencies": {
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "rollup": "^4.22.4"
   },
   "directories": {
     "lib": "lib",

package/rollup.config.js

@@ -0,0 +1,8 @@
+export default {
+  input: 'lib/terminal.js',
+  output: {
+    file: 'lib/cjs/terminal.cjs',
+    format: 'cjs',
+  },
+  external: ['fs', 'url']
+};

package/tests/terminal.test.js

@@ -1,4 +1,6 @@
-const terminal = require("../index.js");
+const terminal = require("../index.cjs");
+
+const levels = terminal.levels;
 
 describe("Terminal Module", () => {
   beforeEach(() => {
@@ -29,6 +31,23 @@ describe("Terminal Module", () => {
       expect(mockWrite).toHaveBeenCalledWith(expect.stringContaining("PASS"));
       mockWrite.mockRestore();
     });
+
+    it("should use console.log instead of stdout.write when verbose is 2 and msg is an object", () => {
+      terminal.setVerbose(2);
+      const mockLog = jest.spyOn(console, "log").mockImplementation(() => true);
+      const mockWrite = jest
+        .spyOn(process.stdout, "write")
+        .mockImplementation(() => true);
+
+      const message = { key: "value" };
+      terminal.pass(message);
+
+      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining(levels.pass), message);
+      expect(mockWrite).not.toHaveBeenCalled();
+
+      mockLog.mockRestore();
+      mockWrite.mockRestore();
+    });
   });
 
   describe("log", () => {
@@ -39,12 +58,13 @@ describe("Terminal Module", () => {
         .mockImplementation(() => true);
 
       terminal.log("This is a log message");
+      terminal.pass("This is a pass message");
       expect(mockWrite).not.toHaveBeenCalled();
 
       mockWrite.mockRestore();
     });
 
-    it("should write info message to stdout when verbose is 2", () => {
+    it("should write info message to stdout when verbose is 2 and msg is a string", () => {
       terminal.setVerbose(2);
       const mockWrite = jest
         .spyOn(process.stdout, "write")
@@ -55,25 +75,39 @@ describe("Terminal Module", () => {
       mockWrite.mockRestore();
     });
 
-    it("should write error message to stdout when it is an error", () => {
+    it("should use console.log instead of stdout.write when verbose is 2 and msg is an error string", () => {
       terminal.setVerbose(2);
+      const mockLog = jest.spyOn(console, "log").mockImplementation(() => true);
       const mockWrite = jest
         .spyOn(process.stdout, "write")
         .mockImplementation(() => true);
 
-      terminal.log("Error: Something went wrong");
-      expect(mockWrite).toHaveBeenCalledWith(expect.stringContaining("FAIL"));
+      const errorMessage = "Error: Something went wrong";
+
+      terminal.log(errorMessage);
+
+      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining(levels.fail), errorMessage);
+      expect(mockWrite).not.toHaveBeenCalled();
+
+      mockLog.mockRestore();
       mockWrite.mockRestore();
     });
 
-    it("should write object to console.log when data is an object", () => {
+    it("should use console.log instead of stdout.write when verbose is 2 and msg is an object", () => {
       terminal.setVerbose(2);
       const mockLog = jest.spyOn(console, "log").mockImplementation(() => true);
+      const mockWrite = jest
+        .spyOn(process.stdout, "write")
+        .mockImplementation(() => true);
 
-      terminal.log({ key: "value" });
-      expect(mockLog).toHaveBeenCalledWith({ key: "value" });
+      const message = { key: "value" };
+      terminal.log(message);
+
+      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining(levels.info), message);
+      expect(mockWrite).not.toHaveBeenCalled();
 
       mockLog.mockRestore();
+      mockWrite.mockRestore();
     });
   });