colorino 0.13.2 → 0.14.1

package/dist/node.mjs

@@ -1,8 +1,414 @@
-import { C as ColorLevel, d as determineBaseTheme, t as themePalettes, M as MyColorino, I as InputValidator } from './shared/colorino.vAejLjBp.mjs';
+import { err, ok } from 'neverthrow';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 
+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 err(new InputValidationError(`Invalid hex color: '${hex}'`));
+    }
+    return ok(true);
+  }
+  validatePalette(palette) {
+    for (const level in palette) {
+      const hex = palette[level];
+      const result = this.validateHex(hex);
+      if (result.isErr()) {
+        return err(result.error);
+      }
+    }
+    return ok(true);
+  }
+}
+
 const __dirname$1 = dirname(fileURLToPath(import.meta.url));
 function getTerminalThemeSync() {
   const scriptPath = join(__dirname$1, "osc-child-probe.js");
@@ -134,12 +540,12 @@ function createColorino(userPalette = {}, options = {}) {
   const baseThemeName = determineBaseTheme(themeOpt, detectedTerminalTheme);
   const basePalette = themePalettes[baseThemeName];
   const finalPalette = { ...basePalette, ...userPalette };
-  return new MyColorino(
+  const colorLevel = nodeDetector.isNodeEnv() ? nodeDetector.getColorLevel() ?? "UnknownEnv" : "UnknownEnv";
+  return new ColorinoNode(
     finalPalette,
     userPalette,
     validator,
-    void 0,
-    nodeDetector,
+    colorLevel,
     options
   );
 }

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "colorino",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "description": "A super simple colorized logger that gets the most out of your terminal",
   "keywords": [
     "ansi",
+    "chalk",
     "color",
     "console",
+    "kuler",
     "logger",
-    "terminal",
-    "chalk",
-    "kuler"
+    "terminal"
   ],
   "homepage": "https://github.com/simwai/colorino",
   "bugs": {
@@ -28,27 +28,34 @@
     "README.md"
   ],
   "type": "module",
-  "main": "./dist/node.cjs",
+  "main": "./dist/node.mjs",
   "module": "./dist/browser.mjs",
   "types": "./dist/browser.d.ts",
+  "unpkg": "./dist/cdn.min.js",
+  "jsdelivr": "./dist/cdn.min.js",
   "exports": {
     "node": {
       "types": "./dist/node.d.ts",
       "import": "./dist/node.mjs",
       "require": "./dist/node.cjs"
     },
+    "script": "./dist/cdn.min.js",
     "browser": {
       "types": "./dist/browser.d.ts",
       "import": "./dist/browser.mjs",
-      "require": "./dist/browser.cjs"
+      "default": "./dist/browser.mjs"
+    },
+    "default": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.mjs",
+      "default": "./dist/browser.mjs"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "bundle:browser": "node --loader ts-node/esm node_modules/rollup/dist/bin/rollup -c rollup.browser.config.ts",
-    "build": "unbuild && npm run bundle:browser",
+    "build": "unbuild",
     "format": "oxlint --fix && oxfmt",
     "test:all": "npm run test:node && npm run test:browser",
     "test:node": "vitest run --project=node",
@@ -72,7 +79,7 @@
     "@playwright/test": "^1.57.0",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@swc/core": "^1.15.8",
+    "@rollup/plugin-terser": "^0.4.4",
     "@types/node": "^24.9.2",
     "@vitest/browser-playwright": "^4.0.15",
     "@vitest/coverage-v8": "^4.0.15",
@@ -84,7 +91,6 @@
     "oxfmt": "^0.23.0",
     "oxlint": "^0.2.0",
     "playwright": "^1.57.0",
-    "rollup": "^4.54.0",
     "ts-node": "^10.9.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
@@ -99,7 +105,7 @@
     "*.ts": "vitest related --run"
   },
   "engines": {
-    "node": ">=17.0.0",
-    "npm": ">=8.0.0"
+    "node": ">=20.0.0",
+    "npm": ">=9.6.4"
   }
 }