@endgame45/nodescript 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@endgame45/nodescript",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "main": "src/nodescript.js",
   "files": [
     "src"
@@ -24,8 +24,10 @@
     "eslint": "^7.32.0"
   },
   "url": {
-    "repository": "npmjs.com/package/@endgame45/nodescript",
+    "repository": "https://npmjs.com/package/@endgame45/nodescript",
     "type": "git",
-    "url": "github.com/horizon-std/nodescript"
-  }
+    "url": "https://github.com/horizon-std/nodescript"
+  },
+  "bugs": "https://github.com/horizon-std/nodescript/issues",
+  "readme": ""
 }

package/src/nodescript.js

@@ -5,25 +5,75 @@ const SUPPORTED_FONTS = new Set([
     'bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'
 ]);
 
+function clamp(v, a = 0, b = 255) {
+    return Math.min(b, Math.max(a, Math.round(Number(v) || 0)));
+}
+
+function hslToRgb(h, s, l) {
+    // h: 0-360, s,l: 0-1
+    h = ((h % 360) + 360) % 360;
+    s = Math.max(0, Math.min(1, s));
+    l = Math.max(0, Math.min(1, l));
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = l - c / 2;
+    let r1 = 0; let g1 = 0; let b1 = 0;
+    if (h < 60) { r1 = c; g1 = x; b1 = 0; }
+    else if (h < 120) { r1 = x; g1 = c; b1 = 0; }
+    else if (h < 180) { r1 = 0; g1 = c; b1 = x; }
+    else if (h < 240) { r1 = 0; g1 = x; b1 = c; }
+    else if (h < 300) { r1 = x; g1 = 0; b1 = c; }
+    else { r1 = c; g1 = 0; b1 = x; }
+    return [ clamp((r1 + m) * 255), clamp((g1 + m) * 255), clamp((b1 + m) * 255) ];
+}
+
+function blendOverBg(r, g, b, a, bgR = 0, bgG = 0, bgB = 0) {
+    // alpha in 0..1
+    const alpha = Math.max(0, Math.min(1, Number(a) || 0));
+    const rr = Math.round((1 - alpha) * bgR + alpha * r);
+    const gg = Math.round((1 - alpha) * bgG + alpha * g);
+    const bb = Math.round((1 - alpha) * bgB + alpha * b);
+    return [clamp(rr), clamp(gg), clamp(bb)];
+}
+
 function parseColor(styler, color, isBg = false) {
     if (!color) return styler;
     const c = String(color).trim();
+    // hex
+    if (/^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(c)) {
+        return isBg ? styler.bgHex(c) : styler.hex(c);
+    }
+    // rgb() or rgba()
+    const rgbMatch = c.match(/^rgba?\s*\(([^)]+)\)$/i);
+    if (rgbMatch) {
+        const parts = rgbMatch[1].split(',').map(s => s.trim());
+        const r = parseInt(parts[0], 10) || 0;
+        const g = parseInt(parts[1], 10) || 0;
+        const b = parseInt(parts[2], 10) || 0;
+        const a = parts[3] !== undefined ? parseFloat(parts[3]) : 1;
+        if (a >= 1) return isBg ? styler.bgRgb(r, g, b) : styler.rgb(r, g, b);
+        // blend alpha over background if provided via isBg===false and styler has bgColor; we don't know bg, assume black
+        const [rr, gg, bb] = blendOverBg(r, g, b, a, 0, 0, 0);
+        return isBg ? styler.bgRgb(rr, gg, bb) : styler.rgb(rr, gg, bb);
+    }
+    // hsl() or hsla()
+    const hslMatch = c.match(/^hsla?\s*\(([^)]+)\)$/i);
+    if (hslMatch) {
+        const parts = hslMatch[1].split(',').map(s => s.trim());
+        const h = parseFloat(parts[0]) || 0;
+        const s = (String(parts[1]).replace('%', '') || 0) / 100;
+        const l = (String(parts[2]).replace('%', '') || 0) / 100;
+        const a = parts[3] !== undefined ? parseFloat(parts[3]) : 1;
+        const [r, g, b] = hslToRgb(h, s, l);
+        if (a >= 1) return isBg ? styler.bgRgb(r, g, b) : styler.rgb(r, g, b);
+        const [rr, gg, bb] = blendOverBg(r, g, b, a, 0, 0, 0);
+        return isBg ? styler.bgRgb(rr, gg, bb) : styler.rgb(rr, gg, bb);
+    }
+    // fallback to CSS keyword (named color)
     try {
-        if (/^#/.test(c)) {
-            return isBg ? styler.bgHex(c) : styler.hex(c);
-        }
-        if (/^rgb\(/i.test(c)) {
-            const nums = c
-                .replace(/^[^(]*\(/, '')
-                .replace(/\).*/, '')
-                .split(',')
-                .map(n => parseInt(n, 10) || 0);
-            return isBg ? styler.bgRgb(nums[0], nums[1], nums[2]) : styler.rgb(nums[0], nums[1], nums[2]);
-        }
-        // fallback to CSS keyword (named color)
         return isBg ? styler.bgKeyword(c) : styler.keyword(c);
     } catch (e) {
-        return styler; // if chalk call fails, return base styler
+        return styler;
     }
 }
 
@@ -225,8 +275,35 @@ const nsc = {
     textColor: null,
     bgColor: null,
     font: null,
+    namespace: null,
+    // logging level: error, warn, info, debug
+    level: 'info',
+    levels: { error: 0, warn: 1, info: 2, debug: 3 },
+    // auto color detection (respects NO_COLOR and TTY)
+    autoColor: true,
+    // timestamping options: { enabled: false, format: 'iso'|'local'|function }
+    timestamp: { enabled: false, format: 'iso' },
+
+    _colorEnabled() {
+        if (!this.autoColor) return false;
+        if (process && process.env && process.env.NO_COLOR) return false;
+        return Boolean(process && process.stdout && process.stdout.isTTY);
+    },
 
     _getStyler() {
+        if (!this._colorEnabled()) {
+            // minimal no-color styler that mimics chalk chaining API
+            const noColor = (s) => String(s);
+            const fonts = ['bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'];
+            for (const f of fonts) noColor[f] = noColor;
+            noColor.hex = () => noColor;
+            noColor.bgHex = () => noColor;
+            noColor.rgb = () => noColor;
+            noColor.bgRgb = () => noColor;
+            noColor.keyword = () => noColor;
+            noColor.bgKeyword = () => noColor;
+            return noColor;
+        }
         return buildStyler({
             textColor: this.textColor,
             bgColor: this.bgColor,
@@ -234,36 +311,81 @@ const nsc = {
         });
     },
 
-    // nsc.log can be used in two ways:
-    // 1) nsc.log('a', 'b', 123)
-    // 2) nsc.log(() => { console.log('inside will be styled') })   <-- temporary override of console.log
-    log(...args) {
-        // callback-mode: override console.log while invoking the function
+    _formatPrefix(level) {
+        const parts = [];
+        if (this.timestamp && this.timestamp.enabled) {
+            const fmt = this.timestamp.format;
+            let ts = '';
+            if (typeof fmt === 'function') ts = String(fmt());
+            else if (fmt === 'local') ts = new Date().toLocaleString();
+            else ts = new Date().toISOString();
+            parts.push(ts);
+        }
+        if (this.namespace) parts.push(this.namespace);
+        if (level) parts.push(level.toUpperCase());
+        return parts.length ? '[' + parts.join('] [') + '] ' : '';
+    },
+
+    _shouldLog(level) {
+        const cur = this.levels[this.level] ?? 2;
+        const lvl = this.levels[level] ?? 2;
+        return lvl <= cur;
+    },
+
+    _printStyled(text, level) {
+        // choose effective color without mutating instance
+        let defaultColor;
+        switch (level) {
+            case 'error': defaultColor = 'red'; break;
+            case 'warn': defaultColor = 'yellow'; break;
+            case 'info': defaultColor = 'cyan'; break;
+            case 'debug': defaultColor = 'magenta'; break;
+            default: defaultColor = null; break;
+        }
+        let styler;
+        if (!this._colorEnabled()) {
+            const noColor = (s) => String(s);
+            const fonts = ['bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'];
+            for (const f of fonts) noColor[f] = noColor;
+            noColor.hex = () => noColor;
+            noColor.bgHex = () => noColor;
+            noColor.rgb = () => noColor;
+            noColor.bgRgb = () => noColor;
+            noColor.keyword = () => noColor;
+            noColor.bgKeyword = () => noColor;
+            styler = noColor;
+        } else {
+            styler = buildStyler({
+                textColor: this.textColor || defaultColor,
+                bgColor: this.bgColor,
+                font: this.font
+            });
+        }
+        const out = styler(text);
+        console.log(out);
+    },
+
+    // low-level logging method used by level helpers
+    _log(level, ...args) {
+        if (level && !this._shouldLog(level)) return;
+        // support callback-mode where a function temporarily overrides console.log
         if (args.length === 1 && typeof args[0] === 'function') {
             const fn = args[0];
             const originalLog = console.log;
+            const prefix = this._formatPrefix(level);
             const styler = this._getStyler();
 
             console.log = (...innerArgs) => {
                 const out = util.format(...innerArgs);
-                originalLog(styler(out));
+                originalLog(prefix + styler(out));
             };
 
             try {
                 const result = fn();
-                // support async callbacks (promises)
                 if (result && typeof result.then === 'function') {
-                    return result
-                        .then(res => {
-                            console.log = originalLog;
-                            return res;
-                        })
-                        .catch(err => {
-                            console.log = originalLog;
-                            throw err;
-                        });
+                    return result.then((res) => { console.log = originalLog; return res; })
+                        .catch((err) => { console.log = originalLog; throw err; });
                 }
-                // sync
                 console.log = originalLog;
                 return result;
             } catch (err) {
@@ -272,10 +394,91 @@ const nsc = {
             }
         }
 
-        // normal-mode: format args and print styled
+        const prefix = this._formatPrefix(level);
+        const message = util.format(...args);
+        // combine prefix and message
+        const full = prefix + message;
+        this._printStyled(full, level);
+    },
+
+    // public API: default log (info-level)
+    log(...args) { return this._log('info', ...args); },
+
+    info(...args) { return this._log('info', ...args); },
+    warn(...args) { return this._log('warn', ...args); },
+    error(...args) { return this._log('error', ...args); },
+    debug(...args) { return this._log('debug', ...args); },
+
+    // create a namespaced logger instance with optional defaults
+    create(namespace, opts = {}) {
+        const inst = Object.create(this);
+        inst.namespace = namespace || null;
+        if (opts.textColor) inst.textColor = opts.textColor;
+        if (opts.bgColor) inst.bgColor = opts.bgColor;
+        if (opts.font) inst.font = opts.font;
+        if (opts.level) inst.level = opts.level;
+        if (typeof opts.autoColor === 'boolean') inst.autoColor = opts.autoColor;
+        if (opts.timestamp) inst.timestamp = Object.assign({}, inst.timestamp, opts.timestamp);
+        // bind methods to instance for convenience
+        inst.log = inst.log.bind(inst);
+        inst.info = inst.info.bind(inst);
+        inst.warn = inst.warn.bind(inst);
+        inst.error = inst.error.bind(inst);
+        inst.debug = inst.debug.bind(inst);
+        inst.create = inst.create.bind(inst);
+        return inst;
+    },
+    // theme registry
+    _themes: new Map(),
+    registerTheme(name, opts) {
+        if (!name || typeof name !== 'string') throw new TypeError('theme name must be a string');
+        if (!opts || typeof opts !== 'object') throw new TypeError('theme opts must be an object');
+        // store a shallow copy
+        this._themes.set(name, Object.assign({}, opts));
+        return this;
+    },
+    getTheme(name) {
+        return this._themes.get(name) || null;
+    },
+    // apply theme to this instance (mutates)
+    applyTheme(name) {
+        const t = this.getTheme(name);
+        if (!t) throw new Error('unknown theme: ' + name);
+        if (t.textColor) this.textColor = t.textColor;
+        if (t.bgColor) this.bgColor = t.bgColor;
+        if (t.font) this.font = t.font;
+        if (t.level) this.level = t.level;
+        if (t.timestamp) this.timestamp = Object.assign({}, this.timestamp, t.timestamp);
+        return this;
+    },
+    // return a new instance pre-configured with theme
+    useTheme(name) {
+        const t = this.getTheme(name);
+        if (!t) throw new Error('unknown theme: ' + name);
+        return this.create(null, t);
+    },
+
+    // tagged template helper: returns styled string (does not log)
+    style(strings, ...values) {
+        // combine template parts, evaluating functions
+        const parts = [];
+        for (let i = 0; i < strings.length; i++) {
+            parts.push(strings[i]);
+            if (i < values.length) {
+                const v = values[i];
+                if (typeof v === 'function') parts.push(String(v()));
+                else parts.push(String(v));
+            }
+        }
+        const full = parts.join('');
         const styler = this._getStyler();
-        const out = util.format(...args);
-        console.log(styler(out));
+        return styler(full);
+    },
+
+    // convenience: styled log via template tag
+    tagLog(strings, ...values) {
+        const s = this.style(strings, ...values);
+        console.log(s);
     },
 
     /**