@guritso/terminal 1.2.2 → 1.2.3

package/lib/dist/terminal.cjs

@@ -0,0 +1,328 @@
+'use strict';
+
+var url = require('url');
+var fs = require('fs');
+var path = require('path');
+
+/*!
+ * Terminal
+ * Copyright (c) 2024 @guritso
+ * @license MIT
+ */
+
+
+/**
+ * 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;
+
+    let code = n;
+    if (n >= 40 && n <= 47) {
+      code = `90;${n}`;
+    } else if (n >= 100 && n <= 107) {
+      code = `97;${n}`;
+    }
+
+    const mo = `\x1b[${code}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 MIT
+ */
+
+
+/**
+ * @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
+ * @property {function(string): void} loadProjectInfo
+ */
+const terminal = {
+  verbose: 2,
+   levels: {
+     info: color("%H47  INFO %H"),
+     fail: color("%H41  FAIL %H"),
+     pass: color("%H42  PASS %H"),
+   },
+};
+
+const { stdout } = process;
+
+terminal.projectInfo = { 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) {
+  if (terminal.projectInfo.name === "unknown") {
+    terminal.loadProjectInfo();
+  }
+  const projectInfo = terminal.projectInfo;
+  const hostInfo = formatUrl(host, port);
+
+   const headLines = [
+     `\n%H46  name:%H%H33  ${projectInfo.name}`,
+     `%H%H31  ${projectInfo.version} %H\n`,
+     hostInfo?.url ? `%H43  host:%H %H36 ${hostInfo.url}%H\n` : "",
+     hostInfo?.port ? `%H45  port:%H %H31 ${hostInfo.port}%H\n` : "",
+   ];
+
+  for (const line of headLines) {
+    stdout.write(color(line));
+  }
+};
+
+/**
+ *  display successful messages
+ *
+ * @param {string} data
+ */
+terminal.pass = function pass(data) {
+  if (data === null || data === undefined) return;
+
+  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);
+    }
+  }
+};
+// cache
+let errorKeywords = [];
+
+/**
+ * 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") {
+    if (!errorKeywords.length) {
+      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;
+    }
+  }
+};
+
+/**
+ * Restore terminal.log function
+ * @return {boolean} if true = sucess
+ */
+terminal.teardown = () => {
+  if (console.backup) {
+    console.error = console.backup;
+    delete console.backup;
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Load project info from package.json
+ * @param {string} [pkgPath] - Optional path to package.json
+ */
+terminal.loadProjectInfo = (pkgPath) => {
+  try {
+    const path$1 = pkgPath || path.resolve(process.cwd(), "package.json");
+    const pkgData = JSON.parse(fs.readFileSync(path$1, "utf-8"));
+
+    terminal.projectInfo = {
+      name: pkgData.name || "unknown",
+      version: pkgData.version || "unknown"
+    };
+  } catch (error) {
+    terminal.projectInfo = { name: "unknown", version: "unknown" };
+  }
+};
+
+module.exports = terminal;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@guritso/terminal",
   "description": "A terminal node utility for enhanced logging and error handling",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "main": "index.cjs",
   "module": "index.js",
   "types": "index.d.ts",
@@ -34,12 +34,16 @@
     "jest": "^30.2.0",
     "rollup": "^4.55.3"
   },
-  "directories": {
-    "lib": "lib",
-    "test": "tests"
-  },
+  "files": [
+    "index.js",
+    "index.cjs",
+    "index.d.ts",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
   "bugs": {
     "url": "https://github.com/guritso/terminal/issues"
   },
   "homepage": "https://github.com/guritso/terminal#readme"
-}
+}

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [20.x, 22.x, 24.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test

package/.github/workflows/npm-publish.yml

@@ -1,38 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24.x
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24.x
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/rollup.config.js

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

package/tests/terminal.test.js

@@ -1,215 +0,0 @@
-const terminal = require("../index.cjs");
-
-const levels = terminal.levels;
-
-describe("Terminal Module", () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe("start", () => {
-    it("should write project information and port to stdout", () => {
-      const mockWrite = jest
-        .spyOn(process.stdout, "write")
-        .mockImplementation(() => true);
-      terminal.projectInfo = { name: "test-project", version: "1.0.0" };
-
-      terminal.start("localhost", 3000);
-
-      expect(mockWrite).toHaveBeenCalled();
-      mockWrite.mockRestore();
-    });
-  });
-
-  describe("pass", () => {
-    it("should write success message to stdout", () => {
-      const mockWrite = jest
-        .spyOn(process.stdout, "write")
-        .mockImplementation(() => true);
-      terminal.pass("Operation successful");
-
-      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", () => {
-    it("should do nothing if verbose is 0", () => {
-      terminal.setVerbose(0);
-      const mockWrite = jest
-        .spyOn(process.stdout, "write")
-        .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 and msg is a string", () => {
-      terminal.setVerbose(2);
-      const mockWrite = jest
-        .spyOn(process.stdout, "write")
-        .mockImplementation(() => true);
-
-      terminal.log("Info message");
-      expect(mockWrite).toHaveBeenCalledWith(expect.stringContaining("INFO"));
-      mockWrite.mockRestore();
-    });
-
-    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);
-
-      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 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.log(message);
-
-      expect(mockLog).toHaveBeenCalledWith(expect.stringContaining(levels.info), message);
-      expect(mockWrite).not.toHaveBeenCalled();
-
-      mockLog.mockRestore();
-      mockWrite.mockRestore();
-    });
-  });
-
-  describe("isError", () => {
-    it("should return true if the data is an instance of Error", () => {
-      const error = new Error("Test error");
-      expect(terminal.isError(error)).toBe(true);
-    });
-
-    it("should return true if the string contains an error keyword", () => {
-      expect(terminal.isError("Error: Test error")).toBe(true);
-    });
-
-    it("should return false for data that is not an error", () => {
-      expect(terminal.isError("This is a message")).toBe(false);
-      expect(terminal.isError({})).toBe(false);
-      expect(terminal.isError(123)).toBe(false);
-    });
-  });
-
-  describe("setup", () => {
-    it("should replace console.error with terminal.log", () => {
-      const originalError = console.error;
-      terminal.setup();
-
-      expect(console.error).toBe(terminal.log);
-
-      console.error = originalError;
-    });
-
-    it("should backup the original console.error", () => {
-      const originalError = console.error;
-
-      terminal.setup();
-
-      expect(console.backup).toBe(originalError);
-
-      console.error = originalError;
-    });
-
-    it("should not replace console.error if console.backup exists", () => {
-      console.backup = jest.fn();
-      const originalError = console.error;
-      const result = terminal.setup();
-
-      expect(result).toBe(false);
-      expect(console.error).toBe(originalError);
-
-      delete console.backup;
-    });
-
-    it("should throw an error if console.error is not found", () => {
-      const originalConsole = global.console;
-      global.console = { log: jest.fn() };
-
-      expect(() => terminal.setup()).toThrow("console.error is not found");
-
-      global.console = originalConsole;
-    });
-  });
-
-  describe("clear", () => {
-    it("should call stdout.clearLine if stdout is TTY", () => {
-      const originalIsTTY = process.stdout.isTTY;
-      process.stdout.isTTY = true;
-
-      if (!process.stdout.clearLine) {
-        process.stdout.clearLine = jest.fn();
-      }
-
-      const mockClearLine = jest
-        .spyOn(process.stdout, "clearLine")
-        .mockImplementation(() => true);
-      terminal.clear();
-      expect(mockClearLine).toHaveBeenCalled();
-
-      mockClearLine.mockRestore();
-      process.stdout.isTTY = originalIsTTY;
-      delete process.stdout.clearLine;
-    });
-
-    it("should not call stdout.clearLine if stdout is not TTY", () => {
-      const originalIsTTY = process.stdout.isTTY;
-      process.stdout.isTTY = false;
-
-      process.stdout.clearLine = jest.fn();
-
-      const mockClearLine = jest.spyOn(process.stdout, "clearLine");
-
-      terminal.clear();
-      expect(mockClearLine).not.toHaveBeenCalled();
-
-      mockClearLine.mockRestore();
-      process.stdout.isTTY = originalIsTTY;
-      delete process.stdout.clearLine;
-    });
-  });
-
-  describe("setVerbose", () => {
-    it("should update the verbose level", () => {
-      terminal.setVerbose(1);
-      expect(terminal.verbose).toBe(1);
-    });
-  });
-});