colorino 0.1.0

package/dist/node.mjs

@@ -0,0 +1,191 @@
+import { O as OscQueryError, C as ColorLevel, a as Colorino, I as InputValidator, d as darkDraculaPalette } from './shared/colorino.xxLMfJFV.mjs';
+import { err, ok } from 'neverthrow';
+
+class OscThemeQuerier {
+  constructor(_stdin, _stdout, _timeout = 300, _cacheTtl = 36e5) {
+    this._stdin = _stdin;
+    this._stdout = _stdout;
+    this._timeout = _timeout;
+    this._cacheTtl = _cacheTtl;
+  }
+  cachedResult;
+  cacheTimestamp;
+  async query() {
+    if (!this._stdout.isTTY || typeof this._stdin.setRawMode !== "function") {
+      return err(new OscQueryError("Not a TTY environment"));
+    }
+    const now = Date.now();
+    if (this.cachedResult !== void 0 && this.cacheTimestamp !== void 0 && now - this.cacheTimestamp < this._cacheTtl) {
+      return this.cachedResult;
+    }
+    const result = await this._performQuery();
+    this.cachedResult = result;
+    this.cacheTimestamp = now;
+    return result;
+  }
+  async _performQuery() {
+    return new Promise((resolve) => {
+      const originalRawMode = this._stdin.isRaw;
+      let buffer = "";
+      let isResolved = false;
+      const cleanup = () => {
+        if (isResolved) return;
+        isResolved = true;
+        clearTimeout(timer);
+        this._stdin.removeListener("data", onData);
+        this._stdin.setRawMode(originalRawMode);
+      };
+      const onData = (chunk) => {
+        buffer += chunk.toString();
+        const parseResult = this._parseResponse(buffer);
+        if (parseResult.isOk()) {
+          cleanup();
+          resolve(parseResult);
+        }
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve(
+          err(new OscQueryError("OSC query timeout - terminal did not respond"))
+        );
+      }, this._timeout);
+      this._stdin.setRawMode(true);
+      this._stdin.on("data", onData);
+      this._stdout.write("\x1B]11;?\x1B\\");
+    });
+  }
+  _parseResponse(response) {
+    const rgbMatch = response.match(
+      /rgb:([0-9a-f]{2,4})\/([0-9a-f]{2,4})\/([0-9a-f]{2,4})/i
+    );
+    if (!rgbMatch) {
+      return err(new OscQueryError("No valid OSC response found in buffer"));
+    }
+    const red = this._normalizeHex(rgbMatch[1]);
+    const green = this._normalizeHex(rgbMatch[2]);
+    const blue = this._normalizeHex(rgbMatch[3]);
+    const luminance = this._calculateLuminance(red, green, blue);
+    return ok(luminance < 0.5 ? "dark" : "light");
+  }
+  _normalizeHex(hexValue) {
+    const normalized = hexValue.padEnd(4, "0").slice(0, 2);
+    return parseInt(normalized, 16);
+  }
+  _calculateLuminance(red, green, blue) {
+    return (0.299 * red + 0.587 * green + 0.114 * blue) / 255;
+  }
+}
+
+class NodeColorSupportDetector {
+  constructor(_process, overrideTheme) {
+    this._process = _process;
+    if (!this.isNodeEnv()) return;
+    const processEnv = _process.env;
+    this._envForceColor = processEnv["FORCE_COLOR"];
+    this._envNoColor = processEnv["NO_COLOR"];
+    this._envTerm = processEnv["TERM"];
+    this._envColorTerm = processEnv["COLORTERM"];
+    this._envCliColor = processEnv["CLICOLOR"];
+    this._envCliColorForce = processEnv["CLICOLOR_FORCE"];
+    this._envWtSession = processEnv["WT_SESSION"];
+    this._isTTY = !!_process.stdout.isTTY;
+    this._overrideTheme = overrideTheme;
+    if (!this._overrideTheme && this._isTTY && typeof this._process.stdin.setRawMode === "function") {
+      this._querier = new OscThemeQuerier(
+        this._process.stdin,
+        this._process.stdout
+      );
+    }
+  }
+  _envForceColor;
+  _envTerm;
+  _envColorTerm;
+  _envNoColor;
+  _envCliColor;
+  _envCliColorForce;
+  _envWtSession;
+  _isTTY;
+  _querier;
+  _overrideTheme;
+  isNodeEnv() {
+    return typeof this._process !== "undefined";
+  }
+  getColorLevel() {
+    if (this._envNoColor !== void 0) {
+      return ColorLevel.NO_COLOR;
+    }
+    if (this._envForceColor !== void 0) {
+      if (this._envForceColor === "0" || this._envForceColor === "false") {
+        return ColorLevel.NO_COLOR;
+      }
+      if (this._envForceColor === "1" || this._envForceColor === "true") {
+        return ColorLevel.ANSI;
+      }
+      const level = parseInt(this._envForceColor, 10);
+      if (level >= 0 && level <= 3) {
+        return level;
+      }
+      return ColorLevel.ANSI;
+    }
+    const isForced = this._envCliColorForce !== void 0 && this._envCliColorForce !== "0";
+    if (!this._isTTY && !isForced) {
+      return ColorLevel.NO_COLOR;
+    }
+    if (this._envTerm === "dumb") {
+      return ColorLevel.NO_COLOR;
+    }
+    if (this._envColorTerm === "truecolor" || this._envColorTerm === "24bit") {
+      return ColorLevel.TRUECOLOR;
+    }
+    if (this._envWtSession !== void 0) {
+      return ColorLevel.TRUECOLOR;
+    }
+    if (this._envTerm) {
+      if (/^xterm-kitty$/.test(this._envTerm) || /^xterm-ghostty$/.test(this._envTerm) || /^wezterm$/.test(this._envTerm) || /-truecolor$/.test(this._envTerm)) {
+        return ColorLevel.TRUECOLOR;
+      }
+      if (/-256(color)?$/i.test(this._envTerm)) {
+        return ColorLevel.ANSI256;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
+        this._envTerm
+      )) {
+        return ColorLevel.ANSI;
+      }
+    }
+    if (this._envColorTerm) {
+      return ColorLevel.ANSI;
+    }
+    if (this._envCliColor !== void 0 && this._envCliColor !== "0") {
+      return ColorLevel.ANSI;
+    }
+    return this._isTTY ? ColorLevel.ANSI : ColorLevel.NO_COLOR;
+  }
+  async getTheme() {
+    if (this._overrideTheme) {
+      return this._overrideTheme;
+    }
+    if (!this.isNodeEnv() || !this._isTTY || !this._querier) {
+      return "unknown";
+    }
+    const result = await this._querier.query();
+    return result.unwrapOr("unknown");
+  }
+}
+
+function createColorino(palette, options = {}) {
+  const validator = new InputValidator();
+  const nodeDetector = new NodeColorSupportDetector(process, options.theme);
+  return new Colorino(
+    palette,
+    validator,
+    void 0,
+    // Browser detector is never available
+    nodeDetector,
+    // Always use node detector
+    options
+  );
+}
+const colorino = createColorino(darkDraculaPalette);
+
+export { colorino, createColorino };

package/dist/shared/colorino.BCUN0J9y.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+const neverthrow = require('neverthrow');
+
+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))
+  }};
+
+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 || {});
+
+function isConsoleMethod(level) {
+  return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
+}
+
+class Colorino {
+  constructor(_palette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
+    this._palette = _palette;
+    this._validator = _validator;
+    this._browserColorSupportDetector = _browserColorSupportDetector;
+    this._nodeColorSupportDetector = _nodeColorSupportDetector;
+    this._options = _options;
+    this._colorLevel = this._detectColorSupport();
+    const validatePaletteResult = this._validator.validatePalette(this._palette);
+    if (validatePaletteResult.isErr()) throw validatePaletteResult.error;
+    if ((this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") && !this._options.disableWarnings) {
+      this._maybeWarnUser();
+    }
+  }
+  _alreadyWarned = false;
+  _colorLevel;
+  color(level, text) {
+    const hex = this._palette[level];
+    let ansiCode;
+    switch (this._colorLevel) {
+      case ColorLevel.TRUECOLOR: {
+        const [r, g, b] = colorConverter.hex.toRgb(hex);
+        ansiCode = `\x1B[38;2;${r};${g};${b}m`;
+        break;
+      }
+      case ColorLevel.ANSI256: {
+        const code = colorConverter.hex.toAnsi256(hex);
+        ansiCode = `\x1B[38;5;${code}m`;
+        break;
+      }
+      case ColorLevel.ANSI: {
+        const code = colorConverter.hex.toAnsi16(hex);
+        if (code < 38) {
+          ansiCode = `\x1B[${code}m`;
+        } else {
+          ansiCode = `\x1B[${code}m`;
+        }
+        break;
+      }
+      case "UnknownEnv": {
+        return text;
+      }
+      default:
+        return text;
+    }
+    return `${ansiCode}${text}\x1B[0m`;
+  }
+  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);
+  }
+  _detectColorSupport() {
+    const isBrowserEnv = this._browserColorSupportDetector?.isBrowserEnv();
+    if (isBrowserEnv) {
+      this._colorLevel = this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
+      return this._colorLevel;
+    }
+    const isNodeEnv = this._nodeColorSupportDetector?.isNodeEnv();
+    if (isNodeEnv) {
+      this._colorLevel = this._nodeColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
+      return this._colorLevel;
+    }
+    return "UnknownEnv";
+  }
+  _maybeWarnUser() {
+    if (this._alreadyWarned) return;
+    this._alreadyWarned = true;
+    console.warn(
+      "[Colorino] No ANSI color support detected in this terminal. See https://github.com/chalk/supports-color#support-matrix to learn how to enable terminal color."
+    );
+  }
+  _out(level, args) {
+    const processedArgs = args.map(
+      (arg) => typeof arg === "string" ? this.color(level, arg) : arg
+    );
+    if (isConsoleMethod(level)) console[level](...processedArgs);
+    else console.log(...processedArgs);
+  }
+}
+
+class ColorinoError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ColorinoError";
+    Object.setPrototypeOf(this, ColorinoError.prototype);
+  }
+}
+class OscQueryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OscQueryError";
+  }
+}
+
+class InputValidator {
+  validateHex(hex) {
+    const trimmedHex = hex.trim();
+    const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
+    if (!isHexValid) {
+      return neverthrow.err(new ColorinoError(`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 darkDraculaPalette = {
+  log: "#f8f8f2",
+  debug: "#f1fa8c",
+  error: "#ff5555",
+  info: "	#8be9fd",
+  trace: "#bd93f9",
+  warn: "#ffb86c"
+};
+
+exports.ColorLevel = ColorLevel;
+exports.Colorino = Colorino;
+exports.InputValidator = InputValidator;
+exports.OscQueryError = OscQueryError;
+exports.darkDraculaPalette = darkDraculaPalette;

package/dist/shared/colorino.V5I9NhYv.d.cts

@@ -0,0 +1,89 @@
+import { Result } from 'neverthrow';
+
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'trace' | 'debug';
+type LogLevel = ConsoleMethod & string;
+type Palette = Record<LogLevel, string>;
+type TerminalTheme = 'dark' | 'light' | 'unknown';
+interface ColorinoOptions {
+    disableWarnings?: boolean;
+    theme?: TerminalTheme;
+}
+
+declare enum ColorLevel {
+    NO_COLOR = 0,
+    ANSI = 1,
+    ANSI256 = 2,
+    TRUECOLOR = 3
+}
+
+interface ColorSupportDetectorInterface {
+    getColorLevel(): ColorLevel;
+}
+
+declare class NodeColorSupportDetector implements ColorSupportDetectorInterface {
+    private readonly _process?;
+    private readonly _envForceColor?;
+    private readonly _envTerm?;
+    private readonly _envColorTerm?;
+    private readonly _envNoColor?;
+    private readonly _envCliColor?;
+    private readonly _envCliColorForce?;
+    private readonly _envWtSession?;
+    private readonly _isTTY?;
+    private readonly _querier?;
+    private readonly _overrideTheme?;
+    constructor(_process?: NodeJS.Process | undefined, overrideTheme?: TerminalTheme);
+    isNodeEnv(): boolean;
+    getColorLevel(): ColorLevel;
+    getTheme(): Promise<TerminalTheme>;
+}
+
+declare class BrowserColorSupportDetector implements ColorSupportDetectorInterface {
+    private readonly _window;
+    private readonly _navigator;
+    private readonly _overrideTheme?;
+    constructor(_window: {
+        document: HTMLDocument;
+        matchMedia(arg0: string): {
+            matches: unknown;
+        };
+    } | undefined, _navigator: {
+        userAgent: string;
+    } | undefined, _overrideTheme?: TerminalTheme | undefined);
+    isBrowserEnv(): boolean;
+    getColorLevel(): ColorLevel;
+    getTheme(): TerminalTheme;
+}
+
+declare class ColorinoError extends Error {
+    constructor(message: string);
+}
+
+declare class InputValidator {
+    validateHex(hex: string): Result<boolean, ColorinoError>;
+    validatePalette(palette: Palette): Result<boolean, ColorinoError>;
+}
+
+declare class Colorino {
+    private readonly _palette;
+    private readonly _validator;
+    private readonly _browserColorSupportDetector?;
+    private readonly _nodeColorSupportDetector?;
+    private readonly _options;
+    private _alreadyWarned;
+    private _colorLevel;
+    constructor(_palette: Palette, _validator: InputValidator, _browserColorSupportDetector?: BrowserColorSupportDetector | undefined, _nodeColorSupportDetector?: NodeColorSupportDetector | undefined, _options?: ColorinoOptions);
+    color(level: LogLevel, text: string): string;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    private _detectColorSupport;
+    private _maybeWarnUser;
+    private _out;
+}
+
+export { Colorino as a };
+export type { ColorinoOptions as C, Palette as P };

package/dist/shared/colorino.V5I9NhYv.d.mts

@@ -0,0 +1,89 @@
+import { Result } from 'neverthrow';
+
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'trace' | 'debug';
+type LogLevel = ConsoleMethod & string;
+type Palette = Record<LogLevel, string>;
+type TerminalTheme = 'dark' | 'light' | 'unknown';
+interface ColorinoOptions {
+    disableWarnings?: boolean;
+    theme?: TerminalTheme;
+}
+
+declare enum ColorLevel {
+    NO_COLOR = 0,
+    ANSI = 1,
+    ANSI256 = 2,
+    TRUECOLOR = 3
+}
+
+interface ColorSupportDetectorInterface {
+    getColorLevel(): ColorLevel;
+}
+
+declare class NodeColorSupportDetector implements ColorSupportDetectorInterface {
+    private readonly _process?;
+    private readonly _envForceColor?;
+    private readonly _envTerm?;
+    private readonly _envColorTerm?;
+    private readonly _envNoColor?;
+    private readonly _envCliColor?;
+    private readonly _envCliColorForce?;
+    private readonly _envWtSession?;
+    private readonly _isTTY?;
+    private readonly _querier?;
+    private readonly _overrideTheme?;
+    constructor(_process?: NodeJS.Process | undefined, overrideTheme?: TerminalTheme);
+    isNodeEnv(): boolean;
+    getColorLevel(): ColorLevel;
+    getTheme(): Promise<TerminalTheme>;
+}
+
+declare class BrowserColorSupportDetector implements ColorSupportDetectorInterface {
+    private readonly _window;
+    private readonly _navigator;
+    private readonly _overrideTheme?;
+    constructor(_window: {
+        document: HTMLDocument;
+        matchMedia(arg0: string): {
+            matches: unknown;
+        };
+    } | undefined, _navigator: {
+        userAgent: string;
+    } | undefined, _overrideTheme?: TerminalTheme | undefined);
+    isBrowserEnv(): boolean;
+    getColorLevel(): ColorLevel;
+    getTheme(): TerminalTheme;
+}
+
+declare class ColorinoError extends Error {
+    constructor(message: string);
+}
+
+declare class InputValidator {
+    validateHex(hex: string): Result<boolean, ColorinoError>;
+    validatePalette(palette: Palette): Result<boolean, ColorinoError>;
+}
+
+declare class Colorino {
+    private readonly _palette;
+    private readonly _validator;
+    private readonly _browserColorSupportDetector?;
+    private readonly _nodeColorSupportDetector?;
+    private readonly _options;
+    private _alreadyWarned;
+    private _colorLevel;
+    constructor(_palette: Palette, _validator: InputValidator, _browserColorSupportDetector?: BrowserColorSupportDetector | undefined, _nodeColorSupportDetector?: NodeColorSupportDetector | undefined, _options?: ColorinoOptions);
+    color(level: LogLevel, text: string): string;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    private _detectColorSupport;
+    private _maybeWarnUser;
+    private _out;
+}
+
+export { Colorino as a };
+export type { ColorinoOptions as C, Palette as P };

package/dist/shared/colorino.V5I9NhYv.d.ts

@@ -0,0 +1,89 @@
+import { Result } from 'neverthrow';
+
+type ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'trace' | 'debug';
+type LogLevel = ConsoleMethod & string;
+type Palette = Record<LogLevel, string>;
+type TerminalTheme = 'dark' | 'light' | 'unknown';
+interface ColorinoOptions {
+    disableWarnings?: boolean;
+    theme?: TerminalTheme;
+}
+
+declare enum ColorLevel {
+    NO_COLOR = 0,
+    ANSI = 1,
+    ANSI256 = 2,
+    TRUECOLOR = 3
+}
+
+interface ColorSupportDetectorInterface {
+    getColorLevel(): ColorLevel;
+}
+
+declare class NodeColorSupportDetector implements ColorSupportDetectorInterface {
+    private readonly _process?;
+    private readonly _envForceColor?;
+    private readonly _envTerm?;
+    private readonly _envColorTerm?;
+    private readonly _envNoColor?;
+    private readonly _envCliColor?;
+    private readonly _envCliColorForce?;
+    private readonly _envWtSession?;
+    private readonly _isTTY?;
+    private readonly _querier?;
+    private readonly _overrideTheme?;
+    constructor(_process?: NodeJS.Process | undefined, overrideTheme?: TerminalTheme);
+    isNodeEnv(): boolean;
+    getColorLevel(): ColorLevel;
+    getTheme(): Promise<TerminalTheme>;
+}
+
+declare class BrowserColorSupportDetector implements ColorSupportDetectorInterface {
+    private readonly _window;
+    private readonly _navigator;
+    private readonly _overrideTheme?;
+    constructor(_window: {
+        document: HTMLDocument;
+        matchMedia(arg0: string): {
+            matches: unknown;
+        };
+    } | undefined, _navigator: {
+        userAgent: string;
+    } | undefined, _overrideTheme?: TerminalTheme | undefined);
+    isBrowserEnv(): boolean;
+    getColorLevel(): ColorLevel;
+    getTheme(): TerminalTheme;
+}
+
+declare class ColorinoError extends Error {
+    constructor(message: string);
+}
+
+declare class InputValidator {
+    validateHex(hex: string): Result<boolean, ColorinoError>;
+    validatePalette(palette: Palette): Result<boolean, ColorinoError>;
+}
+
+declare class Colorino {
+    private readonly _palette;
+    private readonly _validator;
+    private readonly _browserColorSupportDetector?;
+    private readonly _nodeColorSupportDetector?;
+    private readonly _options;
+    private _alreadyWarned;
+    private _colorLevel;
+    constructor(_palette: Palette, _validator: InputValidator, _browserColorSupportDetector?: BrowserColorSupportDetector | undefined, _nodeColorSupportDetector?: NodeColorSupportDetector | undefined, _options?: ColorinoOptions);
+    color(level: LogLevel, text: string): string;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    private _detectColorSupport;
+    private _maybeWarnUser;
+    private _out;
+}
+
+export { Colorino as a };
+export type { ColorinoOptions as C, Palette as P };