cstyler 2.0.1 → 4.0.0

package/README.md

@@ -1,31 +1,73 @@
-# CSTYLER
-Hello World!
+# CSTYLER 🎨
+**A lightweight, powerful console styler by kormoi.com**
 
-Style your console log with your cstyler package by kormoi.com
+`cstyler` is a zero-dependency Node.js toolkit designed to make your terminal output beautiful. It features an intuitive chainable API, support for HEX/RGB colors, and a unique nested inline styling system.
 
-This cstyler kit is fully free to use. You can colorize your console log useing this kit. You can use dot notation to add more style like 'bold, underline, italic, dark(for color), bg for background'. You have all red, green, blue, yellow, cyan, purpal, colors on both text color and background color.
+---
 
-You can not use two color names e.g. 'red.blue'.
-How to use:
-INSTALLING:
+## 🚀 Key Features
+* **Auto-Detection:** Automatically strips styles if the terminal doesn't support them (perfect for logs).
+* **Chainable API:** Mix styles easily using dot notation.
+* **TrueColor Support:** Use HEX and RGB for millions of colors.
+* **Smart Nesting:** Complex nested styling using tagged template literals.
+* **No Overhead:** Built to be fast and lightweight.
 
-> npm install cstyler
->
+---
 
-Then it will install packages.
-IMPORT:
-const cstyle = require("cstyle");
+## 📦 Installation
 
-USE:
-console.log(cstyle.bold.underline.italic.dark.yellow("Here goes your text"));
+```bash
+npm install cstyler
+```
+## 🛠 Usage
+### 1. Basic Styling (Chainable)
+You can combine text styles and colors using simple dot notation.
+JavaScript
+```js
+const cstyler = require("cstyler");
 
-You can add these colors by name: red, green, blue, yellow, purpal, grey. You can darken them with a .dark property accessor. You can add rbg, hex, bgrgb and bghex color using .hex('#123456'), and rgb(100,100,100) and same for bg hex and bg rgb.
+// Bold, Underline, and Yellow text
+console.log(cstyler.bold.underline.yellow("Hello World!"));
 
-Feel free to use.
-<<<<<<< HEAD
-Regards from kormoi.com
-=======
-Regards from
-kormoi.com
-MD NASIRUDDIN AHMED
->>>>>>> 7cb483c (Second commit)
+// Darkened green text
+console.log(cstyler.green.dark("Subtle green message"));
+```
+### 2. Custom Colors (HEX & RGB)
+Go beyond the standard 16 colors with TrueColor support.
+JavaScript
+```js
+// Foreground Colors
+console.log(cstyler.hex('#FF5733')("Vibrant Orange"));
+console.log(cstyler.rgb(100, 150, 200)("Custom Blue"));
+
+// Background Colors
+console.log(cstyler.bgHex('#333').white("White text on dark grey"));
+```
+### 3. Inline Nested Styling (Tagged Templates)
+This is the most powerful way to style complex strings. Use {style text} syntax inside backticks.
+JavaScript
+```js
+console.log(cstyler`
+  {bold.red Critical Error:} {italic.gray Connection failed.} 
+  {bold.green Success! {italic.white kormoi.com is online.}}
+  {hex('#00dbde').bold Powerful custom colors work inside too!}
+`);
+```
+🎨 Available Styles
+| Category | Available Properties |
+| :--- | :--- |
+| **Formatting** | bold, italic, underline, dark |
+| **Colors** | red, green, blue, yellow, purple, cyan, white, gray, magenta |
+| **Backgrounds** | bgRed, bgGreen, bgBlue, bgYellow, bgPurple, bgGray |
+| **Custom** | .hex(), .rgb(), .bgHex(), .bgRgb() |
+
+> Note: You cannot use two foreground colors at once (e.g., red.blue). The last color in the chain will take priority.
+
+## 🛡 Smart Terminal Detection
+`cstyler` is smart. If you pipe your output to a file or run it in an environment that doesn't support ANSI colors, it will **silently return plain text.** Your logs will remain clean and readable without any "garbage" characters.
+
+## 👨‍💻 Author
+### MD NASIRUDDIN AHMED
+Visit us at: kormoi.com
+
+`Feel free to use and contribute! Regards from kormoi.com.`

package/index.js

@@ -1,109 +1,138 @@
 class cstyler {
   constructor() {
-    return this.createStyler([]);
-  }
+    // SILENT CHECK: No printing, just querying the environment
+    this.enabled = process.stdout.isTTY && 
+                   (process.stdout.getColorDepth ? process.stdout.getColorDepth() > 1 : true);
 
-  createStyler(styles) {
-    const styler = (text) => {
-      return styles.reduce((str, styleCode) => styleCode.open + str + styleCode.close, text);
-    };
-
-    const addStyle = (open, close) => this.createStyler([...styles, { open, close }]);
-
-    const styleMap = {
+    this.styleMap = {
       // Text styles
       bold: ['\x1b[1m', '\x1b[22m'],
       italic: ['\x1b[3m', '\x1b[23m'],
       underline: ['\x1b[4m', '\x1b[24m'],
       dark: ['\x1b[2m', '\x1b[22m'],
+
       // Foreground colors
       red: ['\x1b[31m', '\x1b[39m'],
       green: ['\x1b[32m', '\x1b[39m'],
       yellow: ['\x1b[33m', '\x1b[39m'],
       blue: ['\x1b[34m', '\x1b[39m'],
-      purpal: ['\x1b[35m', '\x1b[39m'],
-      gray: ['\x1b[30m', '\x1b[39m'],
+      purple: ['\x1b[35m', '\x1b[39m'],
+      gray: ['\x1b[90m', '\x1b[39m'],
+      white: ['\x1b[97m', '\x1b[39m'],
+      cyan: ['\x1b[36m', '\x1b[39m'],
+      magenta: ['\x1b[35m', '\x1b[39m'],
+
       // Background colors
       bgRed: ['\x1b[41m', '\x1b[49m'],
       bgGreen: ['\x1b[42m', '\x1b[49m'],
       bgYellow: ['\x1b[43m', '\x1b[49m'],
       bgBlue: ['\x1b[44m', '\x1b[49m'],
-      bgPurpal: ['\x1b[45m', '\x1b[49m'],
-      bgGray: ['\x1b[40m', '\x1b[49m']
+      bgPurple: ['\x1b[45m', '\x1b[49m'],
+      bgGray: ['\x1b[100m', '\x1b[49m'],
     };
 
-    // Dynamically define valid style accessors
-    for (const [name, [open, close]] of Object.entries(styleMap)) {
+    return this.createStyler([]);
+  }
+
+  createStyler(styles) {
+    const styler = (text) => {
+      // Return plain text if terminal doesn't support styling
+      if (!this.enabled) return text;
+      return styles.reduce((str, { open, close }) => open + str + close, text);
+    };
+
+    const addStyle = (open, close) => this.createStyler([...styles, { open, close }]);
+
+    // Map standard styles
+    for (const [name, [open, close]] of Object.entries(this.styleMap)) {
       Object.defineProperty(styler, name, {
-        get: () => addStyle(open, close)
+        get: () => this.enabled ? addStyle(open, close) : styler,
       });
     }
 
-    // RGB support
+    // RGB Support
     styler.rgb = (r, g, b) => {
-      if (![r, g, b].every(n => Number.isInteger(n) && n >= 0 && n <= 255)) {
-        console.error('Invalid RGB value. Falling back to white.');
-        return addStyle('\x1b[37m', '\x1b[39m'); // white
-      }
-      const open = `\x1b[38;2;${r};${g};${b}m`;
-      const close = '\x1b[39m';
-      return addStyle(open, close);
+      if (!this.enabled) return styler;
+      return addStyle(`\x1b[38;2;${r};${g};${b}m`, '\x1b[39m');
     };
 
-    // Hex color support
+    // Hex Support
     styler.hex = (hex) => {
-      try {
-        if (typeof hex !== 'string') throw new Error();
-        hex = hex.replace('#', '').slice(0, 6);
-        const r = parseInt(hex.slice(0, 2), 16);
-        const g = parseInt(hex.slice(2, 4), 16);
-        const b = parseInt(hex.slice(4, 6), 16);
-        return styler.rgb(r, g, b);
-      } catch (e) {
-        console.error('Invalid hex color. Falling back to white.');
-        return addStyle('\x1b[37m', '\x1b[39m'); // white
-      }
+      if (!this.enabled) return styler;
+      const cleanHex = hex.replace(/^#/, '');
+      const r = parseInt(cleanHex.slice(0, 2), 16);
+      const g = parseInt(cleanHex.slice(2, 4), 16);
+      const b = parseInt(cleanHex.slice(4, 6), 16);
+      return styler.rgb(r, g, b);
     };
 
-    // Background RGB
-    styler.bgrgb = (r, g, b) => {
-      if (![r, g, b].every(n => Number.isInteger(n) && n >= 0 && n <= 255)) {
-        console.error('Invalid background RGB value. Falling back to white.');
-        return addStyle('\x1b[47m', '\x1b[49m');
-      }
-      const open = `\x1b[48;2;${r};${g};${b}m`;
-      const close = '\x1b[49m';
-      return addStyle(open, close);
+    // Tagged Template Parser
+    styler.tag = (strings, ...values) => {
+      const fullText = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
+      return this.parseInlineStyles(fullText);
     };
 
-    // Background Hex
-    styler.bghex = (hex) => {
-      try {
-        if (typeof hex !== 'string') throw new Error();
-        hex = hex.replace('#', '').slice(0, 6);
-        const r = parseInt(hex.slice(0, 2), 16);
-        const g = parseInt(hex.slice(2, 4), 16);
-        const b = parseInt(hex.slice(4, 6), 16);
-        return styler.bgrgb(r, g, b);
-      } catch (e) {
-        console.error('Invalid background hex. Falling back to white.');
-        return addStyle('\x1b[47m', '\x1b[49m');
-      }
+    this.parseInlineStyles = (text) => {
+      const parse = (str) => {
+        let result = '', i = 0;
+        while (i < str.length) {
+          if (str[i] === '{') {
+            let level = 1, j = i + 1;
+            while (j < str.length && level > 0) {
+              if (str[j] === '{') level++;
+              else if (str[j] === '}') level--;
+              j++;
+            }
+            if (level !== 0) { result += str.slice(i); break; }
+
+            const content = str.slice(i + 1, j - 1);
+            const spaceIdx = content.indexOf(' ');
+
+            if (spaceIdx === -1) {
+              result += '{' + content + '}';
+            } else {
+              const styleStr = content.slice(0, spaceIdx);
+              const innerText = content.slice(spaceIdx + 1);
+              const parsedInner = parse(innerText);
+
+              if (!this.enabled) {
+                result += parsedInner;
+              } else {
+                // regex: match style name OR styleName(params)
+                const styleParts = styleStr.match(/(\w+(\([^)]*\))?)/g) || [];
+                let styledText = parsedInner;
+
+                for (let part of styleParts.reverse()) {
+                  if (part.startsWith('hex')) {
+                    const val = part.match(/\(([^)]+)\)/)?.[1].replace(/['"]/g, '');
+                    styledText = styler.hex(val)(styledText);
+                  } else if (part.startsWith('rgb')) {
+                    const vals = part.match(/\(([^)]+)\)/)?.[1].split(',').map(Number);
+                    styledText = styler.rgb(...vals)(styledText);
+                  } else if (this.styleMap[part]) {
+                    const [open, close] = this.styleMap[part];
+                    styledText = open + styledText + close;
+                  }
+                }
+                result += styledText;
+              }
+            }
+            i = j;
+          } else {
+            result += str[i++];
+          }
+        }
+        return result;
+      };
+      return parse(text);
     };
 
-    // Use Proxy to catch invalid property access
     return new Proxy(styler, {
-      get(target, prop) {
-        if (prop in target) {
-          return target[prop];
-        } else {
-          console.log(`Wrong style: ${String(prop)}`);
-          console.error(`Invalid property accessor used: ${String(prop)}`);
-          return target; // Return unstyled version to continue chain safely
-        }
-      }
+      apply: (target, thisArg, args) => 
+        (Array.isArray(args[0]) && 'raw' in args[0]) ? styler.tag(...args) : styler(...args),
+      get: (target, prop) => (prop in styler) ? styler[prop] : styler,
     });
   }
 }
 
-module.exports = new cstyler();
+module.exports = new cstyler();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cstyler",
-  "version": "2.0.1",
+  "version": "4.0.0",
   "description": "Chainable terminal text styling tool (bold, colors, etc.)",
   "main": "index.js",
   "keywords": [
@@ -10,7 +10,16 @@
     "chainable",
     "bold",
     "style",
-    "styler"
+    "styler",
+    "ansi",
+    "colors",
+    "terminal",
+    "styling",
+    "cli",
+    "template",
+    "rgb",
+    "hex",
+    "hsl"
   ],
   "author": "MD Nasiruddin Ahmed",
   "license": "ISC",

package/readme.txt

@@ -1,23 +0,0 @@
-# cstyler
-Hello World!
-
-You can style with color and style on the console text with this package
-
-This cstyler kit is fully free to use. You can colorize your console log useing this kit. You can use dot notation to add more style like 'bold, underline, italic, dark(for color), bg for background'. You have all red, green, blue, yellow, cyan, purpal, colors on both text color and background color.
-
-You can not use two color names e.g. 'red.blue'.
-How to use:
-INSTALLING:
-
-> npm install cstyler
->
-
-Then it will install packages.
-IMPORT:
-const cstyle = require("cstyle");
-
-USE:
-console.log(cstyle.bold.underline.italic.dark.yellow("Here goes your text"));
-
-Feel free to use.
-Regards from kormoi.com