colorino 0.15.4 → 0.16.0

package/dist/node.mjs

@@ -100,21 +100,9 @@ class AbstractColorino {
       };
     }
     const ansiPrefix = this._toAnsiPrefix(hex);
-    if (!ansiPrefix) {
-      return text;
-    }
+    if (!ansiPrefix) return text;
     return `${ansiPrefix}${text}\x1B[0m`;
   }
-  _out(level, args) {
-    const consoleMethod = TypeValidator.isConsoleMethod(level) ? level : "log";
-    const processedArgs = this._processArgs(args);
-    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
-      this._output(consoleMethod, processedArgs);
-      return;
-    }
-    const coloredArgs = this._applyColors(consoleMethod, processedArgs);
-    this._output(consoleMethod, coloredArgs);
-  }
   _toAnsiPrefix(_hex) {
     return "";
   }
@@ -166,6 +154,16 @@ ${cleanStack}`);
       console.log(...args);
     }
   }
+  _out(level, args) {
+    const consoleMethod = TypeValidator.isConsoleMethod(level) ? level : "log";
+    const processedArgs = this._processArgs(args);
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      this._output(consoleMethod, processedArgs);
+      return;
+    }
+    const coloredArgs = this._applyColors(consoleMethod, processedArgs);
+    this._output(consoleMethod, coloredArgs);
+  }
 }
 
 function hexToRgb(hex) {
@@ -212,17 +210,60 @@ function rgbToAnsi16(rgb) {
   }
   return ansi;
 }
+function interpolateRgb(startRgb, endRgb, steps) {
+  if (steps === 1) return [startRgb];
+  if (steps === 2) return [startRgb, endRgb];
+  const colors = [];
+  for (let i = 0; i < steps; i++) {
+    const ratio = i / (steps - 1);
+    const r = Math.round(startRgb[0] + (endRgb[0] - startRgb[0]) * ratio);
+    const g = Math.round(startRgb[1] + (endRgb[1] - startRgb[1]) * ratio);
+    const b = Math.round(startRgb[2] + (endRgb[2] - startRgb[2]) * ratio);
+    colors.push([r, g, b]);
+  }
+  return colors;
+}
+function hexGradient(startHex, endHex, steps) {
+  const startRgb = hexToRgb(startHex);
+  const endRgb = hexToRgb(endHex);
+  return interpolateRgb(startRgb, endRgb, steps);
+}
 const colorConverter = {
   hex: {
     toRgb: hexToRgb,
     toAnsi16: (hex) => rgbToAnsi16(hexToRgb(hex)),
-    toAnsi256: (hex) => rgbToAnsi256(hexToRgb(hex))
+    toAnsi256: (hex) => rgbToAnsi256(hexToRgb(hex)),
+    gradient: hexGradient
+  },
+  rgb: {
+    toAnsi16: rgbToAnsi16,
+    toAnsi256: rgbToAnsi256,
+    interpolate: interpolateRgb
   }};
 
 class ColorinoNode extends AbstractColorino {
   constructor(initialPalette, userPalette, validator, colorLevel, options = {}) {
     super(initialPalette, userPalette, validator, colorLevel, options);
   }
+  gradient(text, startHex, endHex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv" || this._colorLevel === ColorLevel.ANSI) {
+      return text;
+    }
+    const characters = [...text];
+    const rgbColors = colorConverter.hex.gradient(
+      startHex,
+      endHex,
+      characters.length
+    );
+    return characters.map((char, index) => {
+      const [r, g, b] = rgbColors[index] ?? [0, 0, 0];
+      if (this._colorLevel === ColorLevel.TRUECOLOR) {
+        return `\x1B[38;2;${r};${g};${b}m${char}`;
+      }
+      const code = colorConverter.rgb.toAnsi256([r, g, b]);
+      return `\x1B[38;5;${code}m${char}`;
+    }).join("") + "\x1B[0m";
+  }
   _applyColors(consoleMethod, args) {
     const paletteHex = this._palette[consoleMethod];
     const prefix = this._toAnsiPrefix(paletteHex);
@@ -399,15 +440,7 @@ class InputValidator {
 }
 
 const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-let alreadyWarned = false;
-function getTerminalThemeSync(areWarningsDisabled) {
-  const maybeWarnUser = () => {
-    if (alreadyWarned || areWarningsDisabled) return;
-    alreadyWarned = true;
-    console.warn(
-      "Consider switching the console (Win: Terminal is best) or disabling oscProbe by adding disableOscProbe = true to the options passed into createColorino()."
-    );
-  };
+function getTerminalThemeSync() {
   const scriptPath = join(__dirname$1, "osc-child-probe.js");
   const result = spawnSync(process.execPath, [scriptPath], {
     stdio: ["inherit", "pipe", "inherit"],
@@ -415,20 +448,17 @@ function getTerminalThemeSync(areWarningsDisabled) {
     timeout: 1500
   });
   if (result.error || result.status !== 0) {
-    maybeWarnUser();
     return "unknown";
   }
   const output = result.stdout.trim();
   if (output === "dark" || output === "light") {
     return output;
   }
-  maybeWarnUser();
   return "unknown";
 }
 
 class NodeColorSupportDetector {
-  constructor(_areWarningsDisabled, _process, _overrideTheme, _disableOscProbe = false) {
-    this._areWarningsDisabled = _areWarningsDisabled;
+  constructor(_process, _overrideTheme, _disableOscProbe = false) {
     this._process = _process;
     this._overrideTheme = _overrideTheme;
     this._disableOscProbe = _disableOscProbe;
@@ -438,11 +468,6 @@ class NodeColorSupportDetector {
     }
     if (!this.isNodeEnv()) {
       this._theme = "unknown";
-      if (_areWarningsDisabled && !this._alreadyWarned)
-        this._alreadyWarned = true;
-      console.warn(
-        "NodeColorSupportDetector() called in an env without process API. Don't do this."
-      );
       return;
     }
     this._isTTY = !!_process.stdout.isTTY;
@@ -456,14 +481,9 @@ class NodeColorSupportDetector {
     this._envWtSession = processEnv["WT_SESSION"];
     if (!this._isTTY || this._disableOscProbe) {
       this._theme = "unknown";
-      if (_areWarningsDisabled && !this._alreadyWarned)
-        this._alreadyWarned = true;
-      console.warn(
-        "No theme detected, because of TTY env or disabled OSC probe."
-      );
       return;
     }
-    this._theme = getTerminalThemeSync(_areWarningsDisabled);
+    this._theme = getTerminalThemeSync();
   }
   _envForceColor;
   _envTerm;
@@ -474,7 +494,6 @@ class NodeColorSupportDetector {
   _envWtSession;
   _isTTY;
   _theme;
-  _alreadyWarned;
   isNodeEnv() {
     return typeof this._process !== "undefined";
   }
@@ -547,7 +566,6 @@ function createColorino(userPalette = {}, options = {}) {
     detectorThemeOverride = "unknown";
   }
   const nodeDetector = new NodeColorSupportDetector(
-    !!options.disableWarnings,
     process,
     detectorThemeOverride,
     options.disableOscProbe ?? false

package/dist/osc-child-probe.js

@@ -0,0 +1,66 @@
+const stdin = process.stdin
+const stdout = process.stdout
+const stderr = process.stderr
+
+if (!stdin.isTTY || !stdin.setRawMode) {
+  stdout.write('unknown\n')
+  process.exit(0)
+}
+
+let buffer = ''
+let done = false
+
+const finish = theme => {
+  if (done) return
+  done = true
+
+  stdin.removeListener('data', onData)
+  try {
+    stdin.setRawMode(false)
+  } catch {}
+  stdin.pause()
+
+  stdout.write(theme + '\n')
+  process.exit(0)
+}
+
+const onData = chunk => {
+  buffer += chunk.toString('utf8')
+
+  if (
+    !buffer.includes(']11;rgb:') ||
+    (!buffer.includes('\x07') && !buffer.includes('\x1b\\'))
+  )
+    return
+
+  const match = buffer.match(
+    /rgb:([0-9a-f]{2,4})\/([0-9a-f]{2,4})\/([0-9a-f]{2,4})/i
+  )
+  if (!match) {
+    finish('unknown')
+    return
+  }
+
+  const normalize = hex => {
+    const value = parseInt(hex, 16)
+    const max = (1 << (4 * hex.length)) - 1
+    return Math.round((value / max) * 255)
+  }
+
+  const red = normalize(match[1])
+  const green = normalize(match[2])
+  const blue = normalize(match[3])
+  const luminance = (0.299 * red + 0.587 * green + 0.114 * blue) / 255
+
+  finish(luminance < 0.5 ? 'dark' : 'light')
+}
+
+stdin.on('data', onData)
+stdin.setRawMode(true)
+stdin.resume()
+
+stderr.write('\x1b]11;?\x07')
+
+setTimeout(() => {
+  finish('unknown')
+}, 300)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "colorino",
-  "version": "0.15.4",
+  "version": "0.16.0",
   "description": "A super simple colorized logger that gets the most out of your terminal",
   "keywords": [
     "ansi",