colorino 0.1.0

package/dist/shared/colorino.xxLMfJFV.mjs

@@ -0,0 +1,204 @@
+import { err, ok } from '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 err(new ColorinoError(`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 darkDraculaPalette = {
+  log: "#f8f8f2",
+  debug: "#f1fa8c",
+  error: "#ff5555",
+  info: "	#8be9fd",
+  trace: "#bd93f9",
+  warn: "#ffb86c"
+};
+
+export { ColorLevel as C, InputValidator as I, OscQueryError as O, Colorino as a, darkDraculaPalette as d };

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "colorino",
+  "version": "0.1.0",
+  "description": "A super simple colorized logger that gets the most out of your terminal",
+  "type": "module",
+  "license": "MIT",
+  "author": "simwai",
+  "keywords": [
+    "color",
+    "logger",
+    "terminal",
+    "ansi",
+    "console"
+  ],
+  "homepage": "https://github.com/simwai/colorino",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/simwai/colorino.git"
+  },
+  "bugs": {
+    "url": "https://github.com/simwai/colorino/issues"
+  },
+  "main": "./dist/node.cjs",
+  "module": "./dist/browser.mjs",
+  "types": "./dist/browser.d.ts",
+  "exports": {
+    "node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.mjs",
+      "require": "./dist/node.cjs"
+    },
+    "browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.mjs",
+      "require": "./dist/browser.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "format": "npm run lint:fix && oxfmt",
+    "format:check": "prettier --check .",
+    "check": "npm run lint && npm run format:check",
+    "fix": "npm run lint:fix && npm run format",
+    "test": "npm run test:node && npm run test:browser",
+    "test:node": "vitest run --config vitest.config.ts",
+    "test:browser": "vitest run --config vitest.browser.config.ts",
+    "test:coverage": "vitest run --config vitest.config.ts --coverage",
+    "test:ui": "vitest --ui --config vitest.config.ts",
+    "prepublishonly": "npm run build && npm run test:all && npm run check",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "neverthrow": "^8.2.0"
+  },
+  "devDependencies": {
+    "@sindresorhus/tsconfig": "^8.1.0",
+    "@types/node": "^24.9.2",
+    "@vitest/coverage-v8": "^4.0.6",
+    "@vitest/ui": "^4.0.6",
+    "husky": "^9.0.0",
+    "jsdom": "^27.1.0",
+    "lint-staged": "^15.2.0",
+    "oxfmt": "^0.9.0",
+    "oxlint": "^0.2.0",
+    "tsx": "^4.20.6",
+    "unbuild": "^3.6.1",
+    "vitest": "^4.0.6"
+  },
+  "lint-staged": {
+    "*.{ts,json,md,yml,yaml}": [
+      "oxlint --fix",
+      "oxfmt"
+    ]
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=8.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}