colorino 0.13.2 → 0.14.0

package/dist/node.cjs

@@ -1,11 +1,417 @@
 'use strict';
 
-const inputValidator = require('./shared/colorino.DMgDgITw.cjs');
+const neverthrow = require('neverthrow');
 const node_child_process = require('node:child_process');
 const node_url = require('node:url');
 const node_path = require('node:path');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+const ColorinoBrowserObject = Symbol("colorino.browserObject");
+
+var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
+  ColorLevel2[ColorLevel2["NO_COLOR"] = 0] = "NO_COLOR";
+  ColorLevel2[ColorLevel2["ANSI"] = 1] = "ANSI";
+  ColorLevel2[ColorLevel2["ANSI256"] = 2] = "ANSI256";
+  ColorLevel2[ColorLevel2["TRUECOLOR"] = 3] = "TRUECOLOR";
+  return ColorLevel2;
+})(ColorLevel || {});
+
+class TypeValidator {
+  static isNull(value) {
+    return value === null;
+  }
+  static isUndefined(value) {
+    return value === void 0;
+  }
+  static isNullOrUndefined(value) {
+    return value == null;
+  }
+  static isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  static isString(value) {
+    return typeof value === "string" || value instanceof String;
+  }
+  static isArray(value) {
+    return Array.isArray(value);
+  }
+  static isError(value) {
+    return value instanceof Error;
+  }
+  static isBrowserColorizedArg(value) {
+    return TypeValidator.isObject(value) && ColorinoBrowserColorized in value;
+  }
+  static isBrowserObjectArg(value) {
+    return TypeValidator.isObject(value) && ColorinoBrowserObject in value;
+  }
+  static isAnsiColoredString(value) {
+    return TypeValidator.isString(value) && /\x1b\[[0-9;]*m/.test(value.toString());
+  }
+  static isFormattableObject(value) {
+    return TypeValidator.isObject(value) && !TypeValidator.isError(value) && !TypeValidator.isBrowserColorizedArg(value) && !TypeValidator.isString(value);
+  }
+  static isConsoleMethod(level) {
+    return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
+  }
+}
+
+class AbstractColorino {
+  constructor(initialPalette, _userPalette, _validator, colorLevel, _options = {}) {
+    this._userPalette = _userPalette;
+    this._validator = _validator;
+    this._options = _options;
+    this._palette = initialPalette;
+    const validatePaletteResult = this._validator.validatePalette(this._palette);
+    if (validatePaletteResult.isErr()) throw validatePaletteResult.error;
+    this._colorLevel = colorLevel;
+  }
+  _alreadyWarned = false;
+  _colorLevel;
+  _palette;
+  log(...args) {
+    this._out("log", args);
+  }
+  info(...args) {
+    this._out("info", args);
+  }
+  warn(...args) {
+    this._out("warn", args);
+  }
+  error(...args) {
+    this._out("error", args);
+  }
+  trace(...args) {
+    this._out("trace", args);
+  }
+  debug(...args) {
+    this._out("debug", args);
+  }
+  colorize(text, hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return text;
+    }
+    if (this.isBrowser()) {
+      return {
+        [ColorinoBrowserColorized]: true,
+        text,
+        hex
+      };
+    }
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    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 "";
+  }
+  _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const sanitizeArray = (items, depth) => {
+      return items.map((item) => sanitize(item, depth));
+    };
+    const sanitizeObject = (obj, depth) => {
+      const result = {};
+      for (const key in obj) {
+        result[key] = sanitize(obj[key], depth);
+      }
+      return result;
+    };
+    const sanitize = (val, currentDepth) => {
+      if (TypeValidator.isNullOrUndefined(val) || !TypeValidator.isObject(val)) {
+        return val;
+      }
+      if (seen.has(val)) return "[Circular]";
+      seen.add(val);
+      if (currentDepth >= maxDepth) return "[Object]";
+      const nextDepth = currentDepth + 1;
+      if (TypeValidator.isArray(val)) {
+        return sanitizeArray(val, nextDepth);
+      }
+      return sanitizeObject(val, nextDepth);
+    };
+    return JSON.stringify(sanitize(value, 0), null, 2);
+  }
+  _filterStack(stack) {
+    return stack.split("\n").filter((line) => !line.match(/.*colorino.*/gi)).join("\n");
+  }
+  _cleanErrorStack(error) {
+    if (!error.stack) return error;
+    const cleanStack = this._filterStack(error.stack);
+    const cloned = Object.create(Object.getPrototypeOf(error));
+    Object.assign(cloned, error);
+    cloned.stack = cleanStack;
+    return cloned;
+  }
+  _printCleanTrace(args) {
+    const error = new Error();
+    if (error.stack) {
+      const cleanStack = this._filterStack(error.stack);
+      console.log(...args, `
+${cleanStack}`);
+    } else {
+      console.log(...args);
+    }
+  }
+}
+
+function hexToRgb(hex) {
+  const match = hex.toString().match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+  if (!match) {
+    return [0, 0, 0];
+  }
+  let colorString = match[0];
+  if (match[0].length === 3) {
+    colorString = [...colorString].map((char) => char + char).join("");
+  }
+  const integer = parseInt(colorString, 16);
+  const r = integer >> 16 & 255;
+  const g = integer >> 8 & 255;
+  const b = integer & 255;
+  return [r, g, b];
+}
+function rgbToAnsi256(rgb) {
+  const [r, g, b] = rgb;
+  if (r === g && g === b) {
+    if (r < 8) return 16;
+    if (r > 248) return 231;
+    return Math.round((r - 8) / 247 * 24) + 232;
+  }
+  return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+}
+function rgbToHsvValue(rgb) {
+  const r = rgb[0] / 255;
+  const g = rgb[1] / 255;
+  const b = rgb[2] / 255;
+  const v = Math.max(r, g, b);
+  return v * 100;
+}
+function rgbToAnsi16(rgb) {
+  const [r, g, b] = rgb;
+  const value = rgbToHsvValue(rgb);
+  const roundedValue = Math.round(value / 50);
+  if (roundedValue === 0) {
+    return 30;
+  }
+  let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+  if (roundedValue === 2) {
+    ansi += 60;
+  }
+  return ansi;
+}
+const colorConverter = {
+  hex: {
+    toRgb: hexToRgb,
+    toAnsi16: (hex) => rgbToAnsi16(hexToRgb(hex)),
+    toAnsi256: (hex) => rgbToAnsi256(hexToRgb(hex))
+  }};
+
+class ColorinoNode extends AbstractColorino {
+  constructor(initialPalette, userPalette, validator, colorLevel, options = {}) {
+    super(initialPalette, userPalette, validator, colorLevel, options);
+    this._maybeWarnUser();
+  }
+  applyColors(consoleMethod, args) {
+    const paletteHex = this._palette[consoleMethod];
+    const prefix = this._toAnsiPrefix(paletteHex);
+    if (!prefix) return args;
+    return args.map((arg) => {
+      if (!TypeValidator.isString(arg)) return arg;
+      if (TypeValidator.isAnsiColoredString(arg)) return arg;
+      return `${prefix}${String(arg)}\x1B[0m`;
+    });
+  }
+  output(consoleMethod, args) {
+    if (consoleMethod === "trace") {
+      this._printCleanTrace(args);
+    } else {
+      console[consoleMethod](...args);
+    }
+  }
+  processArgs(args) {
+    const processedArgs = [];
+    let previousWasObject = false;
+    for (const arg of args) {
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        processedArgs.push(arg);
+        previousWasObject = false;
+        continue;
+      }
+      if (TypeValidator.isFormattableObject(arg)) {
+        processedArgs.push(`
+${this._formatValue(arg)}`);
+        previousWasObject = true;
+      } else if (TypeValidator.isError(arg)) {
+        processedArgs.push("\n", this._cleanErrorStack(arg));
+        previousWasObject = true;
+      } else {
+        if (TypeValidator.isString(arg) && previousWasObject) {
+          processedArgs.push(`
+${arg}`);
+        } else {
+          processedArgs.push(arg);
+        }
+        previousWasObject = false;
+      }
+    }
+    return processedArgs;
+  }
+  isBrowser() {
+    return false;
+  }
+  _toAnsiPrefix(hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return "";
+    }
+    switch (this._colorLevel) {
+      case ColorLevel.TRUECOLOR: {
+        const [r, g, b] = colorConverter.hex.toRgb(hex);
+        return `\x1B[38;2;${r};${g};${b}m`;
+      }
+      case ColorLevel.ANSI256: {
+        const code = colorConverter.hex.toAnsi256(hex);
+        return `\x1B[38;5;${code}m`;
+      }
+      case ColorLevel.ANSI:
+      default: {
+        const code = colorConverter.hex.toAnsi16(hex);
+        return `\x1B[${code}m`;
+      }
+    }
+  }
+  _maybeWarnUser() {
+    if (this._alreadyWarned) return;
+    this._alreadyWarned = true;
+    console.warn(
+      "No ANSI color support detected in this terminal. See https://github.com/chalk/supports-color#support-matrix to learn how to enable terminal color."
+    );
+  }
+}
+
+const catppuccinMochaPalette = {
+  log: "#cdd6f4",
+  // Text
+  info: "#89b4fa",
+  // Blue
+  warn: "#f9e2af",
+  // Yellow
+  error: "#f38ba8",
+  // Red
+  debug: "#a6adc8",
+  // Subtext0
+  trace: "#9399b2"
+  // Subtext1
+};
+const catppuccinLattePalette = {
+  log: "#4c4f69",
+  // Text
+  info: "#1e66f5",
+  // Blue
+  warn: "#df8e1d",
+  // Yellow
+  error: "#d20f39",
+  // Red
+  debug: "#7c7f93",
+  // Subtext0
+  trace: "#8c8fa1"
+  // Subtext1
+};
+const draculaPalette = {
+  log: "#f8f8f2",
+  // Foreground
+  info: "#8be9fd",
+  // Cyan
+  warn: "#f1fa8c",
+  // Yellow
+  error: "#ff5555",
+  // Red
+  debug: "#bd93f9",
+  // Purple
+  trace: "#6272a4"
+  // Comment
+};
+const githubLightPalette = {
+  log: "#24292e",
+  // Text
+  info: "#0366d6",
+  // Blue
+  warn: "#f9a002",
+  // Yellow
+  error: "#d73a49",
+  // Red
+  debug: "#586069",
+  // Gray
+  trace: "#6a737d"
+  // Gray-light
+};
+
+const themePalettes = {
+  "catppuccin-mocha": catppuccinMochaPalette,
+  "catppuccin-latte": catppuccinLattePalette,
+  dracula: draculaPalette,
+  "github-light": githubLightPalette
+};
+const defaultDarkTheme = "dracula";
+const defaultLightTheme = "github-light";
+function isThemeName(theme) {
+  return theme in themePalettes;
+}
+
+function determineBaseTheme(themeOpt, detectedBrowserTheme) {
+  let baseThemeName;
+  if (isThemeName(themeOpt)) {
+    baseThemeName = themeOpt;
+  } else if (themeOpt === "light") {
+    baseThemeName = defaultLightTheme;
+  } else if (themeOpt === "dark") {
+    baseThemeName = defaultDarkTheme;
+  } else {
+    baseThemeName = detectedBrowserTheme === "light" ? defaultLightTheme : defaultDarkTheme;
+  }
+  return baseThemeName;
+}
+
+class InputValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InputValidationError";
+    Object.setPrototypeOf(this, InputValidationError.prototype);
+  }
+}
+
+class InputValidator {
+  validateHex(hex) {
+    const trimmedHex = hex.trim();
+    const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
+    if (!isHexValid) {
+      return neverthrow.err(new InputValidationError(`Invalid hex color: '${hex}'`));
+    }
+    return neverthrow.ok(true);
+  }
+  validatePalette(palette) {
+    for (const level in palette) {
+      const hex = palette[level];
+      const result = this.validateHex(hex);
+      if (result.isErr()) {
+        return neverthrow.err(result.error);
+      }
+    }
+    return neverthrow.ok(true);
+  }
+}
+
 const __dirname$1 = node_path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node.cjs', document.baseURI).href))));
 function getTerminalThemeSync() {
   const scriptPath = node_path.join(__dirname$1, "osc-child-probe.js");
@@ -68,59 +474,59 @@ class NodeColorSupportDetector {
   }
   getColorLevel() {
     if (this._envNoColor !== void 0 && this._envNoColor !== "") {
-      return inputValidator.ColorLevel.NO_COLOR;
+      return ColorLevel.NO_COLOR;
     }
     if (this._envForceColor !== void 0) {
       if (this._envForceColor === "0" || this._envForceColor === "false") {
-        return inputValidator.ColorLevel.NO_COLOR;
+        return ColorLevel.NO_COLOR;
       }
       if (this._envForceColor === "1" || this._envForceColor === "true") {
-        return inputValidator.ColorLevel.ANSI;
+        return ColorLevel.ANSI;
       }
       const level = parseInt(this._envForceColor, 10);
       if (level >= 0 && level <= 3) {
         return level;
       }
-      return inputValidator.ColorLevel.ANSI;
+      return ColorLevel.ANSI;
     }
     const isForced = this._envCliColorForce !== void 0 && this._envCliColorForce !== "0";
     if (!this._isTTY && !isForced) {
-      return inputValidator.ColorLevel.NO_COLOR;
+      return ColorLevel.NO_COLOR;
     }
     if (this._envTerm === "dumb") {
-      return inputValidator.ColorLevel.NO_COLOR;
+      return ColorLevel.NO_COLOR;
     }
     if (this._envColorTerm === "truecolor" || this._envColorTerm === "24bit") {
-      return inputValidator.ColorLevel.TRUECOLOR;
+      return ColorLevel.TRUECOLOR;
     }
     if (this._envWtSession !== void 0) {
-      return inputValidator.ColorLevel.TRUECOLOR;
+      return ColorLevel.TRUECOLOR;
     }
     if (this._envTerm) {
       if (/^xterm-kitty$/.test(this._envTerm) || /^xterm-ghostty$/.test(this._envTerm) || /^wezterm$/.test(this._envTerm) || this._envTerm.endsWith("-truecolor")) {
-        return inputValidator.ColorLevel.TRUECOLOR;
+        return ColorLevel.TRUECOLOR;
       }
       if (/-256(color)?$/i.test(this._envTerm)) {
-        return inputValidator.ColorLevel.ANSI256;
+        return ColorLevel.ANSI256;
       }
       if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
         this._envTerm
       )) {
-        return inputValidator.ColorLevel.ANSI;
+        return ColorLevel.ANSI;
       }
     }
     if (this._envColorTerm) {
-      return inputValidator.ColorLevel.ANSI;
+      return ColorLevel.ANSI;
     }
     if (this._envCliColor !== void 0 && this._envCliColor !== "0") {
-      return inputValidator.ColorLevel.ANSI;
+      return ColorLevel.ANSI;
     }
-    return this._isTTY || isForced ? inputValidator.ColorLevel.ANSI : inputValidator.ColorLevel.NO_COLOR;
+    return this._isTTY || isForced ? ColorLevel.ANSI : ColorLevel.NO_COLOR;
   }
 }
 
 function createColorino(userPalette = {}, options = {}) {
-  const validator = new inputValidator.InputValidator();
+  const validator = new InputValidator();
   const themeOpt = options.theme ?? "auto";
   let detectorThemeOverride;
   if (themeOpt === "dark" || themeOpt === "light") {
@@ -134,20 +540,20 @@ function createColorino(userPalette = {}, options = {}) {
     options.disableOscProbe ?? false
   );
   const detectedTerminalTheme = themeOpt === "auto" && !options.disableOscProbe ? nodeDetector.getTheme() : "unknown";
-  const baseThemeName = inputValidator.determineBaseTheme(themeOpt, detectedTerminalTheme);
-  const basePalette = inputValidator.themePalettes[baseThemeName];
+  const baseThemeName = determineBaseTheme(themeOpt, detectedTerminalTheme);
+  const basePalette = themePalettes[baseThemeName];
   const finalPalette = { ...basePalette, ...userPalette };
-  return new inputValidator.MyColorino(
+  const colorLevel = nodeDetector.isNodeEnv() ? nodeDetector.getColorLevel() ?? "UnknownEnv" : "UnknownEnv";
+  return new ColorinoNode(
     finalPalette,
     userPalette,
     validator,
-    void 0,
-    nodeDetector,
+    colorLevel,
     options
   );
 }
 const colorino = createColorino();
 
-exports.themePalettes = inputValidator.themePalettes;
 exports.colorino = colorino;
 exports.createColorino = createColorino;
+exports.themePalettes = themePalettes;

package/dist/node.d.cts

@@ -1,8 +1,29 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.cjs';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.cjs';
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'trace' | 'debug';
+type LogLevel = ConsoleMethod & string;
+type Palette = Record<LogLevel, string>;
+type TerminalTheme = 'dark' | 'light' | 'unknown';
+type ThemeName = 'catppuccin-mocha' | 'catppuccin-latte' | 'dracula' | 'github-light';
+interface ColorinoOptions {
+    disableWarnings?: boolean;
+    theme?: TerminalTheme | ThemeName | 'auto';
+    disableOscProbe?: boolean;
+    maxDepth?: number;
+}
+interface Colorino {
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    colorize(text: string, hex: string): void;
+}
+
+declare const themePalettes: Record<ThemeName, Palette>;
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 
 declare const colorino: Colorino;
 
-export { Colorino, ColorinoOptions, Palette, colorino, createColorino };
+export { colorino, createColorino, themePalettes };
+export type { Colorino, ColorinoOptions, LogLevel, Palette, ThemeName };

package/dist/node.d.mts

@@ -1,8 +1,29 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.mjs';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.mjs';
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'trace' | 'debug';
+type LogLevel = ConsoleMethod & string;
+type Palette = Record<LogLevel, string>;
+type TerminalTheme = 'dark' | 'light' | 'unknown';
+type ThemeName = 'catppuccin-mocha' | 'catppuccin-latte' | 'dracula' | 'github-light';
+interface ColorinoOptions {
+    disableWarnings?: boolean;
+    theme?: TerminalTheme | ThemeName | 'auto';
+    disableOscProbe?: boolean;
+    maxDepth?: number;
+}
+interface Colorino {
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    colorize(text: string, hex: string): void;
+}
+
+declare const themePalettes: Record<ThemeName, Palette>;
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 
 declare const colorino: Colorino;
 
-export { Colorino, ColorinoOptions, Palette, colorino, createColorino };
+export { colorino, createColorino, themePalettes };
+export type { Colorino, ColorinoOptions, LogLevel, Palette, ThemeName };

package/dist/node.d.ts

@@ -1,8 +1,29 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.js';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.js';
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'trace' | 'debug';
+type LogLevel = ConsoleMethod & string;
+type Palette = Record<LogLevel, string>;
+type TerminalTheme = 'dark' | 'light' | 'unknown';
+type ThemeName = 'catppuccin-mocha' | 'catppuccin-latte' | 'dracula' | 'github-light';
+interface ColorinoOptions {
+    disableWarnings?: boolean;
+    theme?: TerminalTheme | ThemeName | 'auto';
+    disableOscProbe?: boolean;
+    maxDepth?: number;
+}
+interface Colorino {
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    colorize(text: string, hex: string): void;
+}
+
+declare const themePalettes: Record<ThemeName, Palette>;
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 
 declare const colorino: Colorino;
 
-export { Colorino, ColorinoOptions, Palette, colorino, createColorino };
+export { colorino, createColorino, themePalettes };
+export type { Colorino, ColorinoOptions, LogLevel, Palette, ThemeName };