@andbc/pigment 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 andbc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# pigment
+
+CLI tool to convert colors between formats.
+
+## Install
+
+```bash
+npm install -g @andbc/pigment
+```
+
+## Usage
+
+```bash
+pigment <color> --to <format> [--from <format>]
+```
+
+## Supported Formats
+
+| Format   | Example input                        | Example output                           |
+|----------|--------------------------------------|------------------------------------------|
+| `hex`    | `#ff6600` / `#ff660080`              | `#ff6600` / `#ff660080`                  |
+| `rgb`    | `rgb(255, 102, 0)`                 | `rgb(255, 102, 0)`                     |
+| `hsl`    | `hsl(24, 100%, 50%)`               | `hsl(24, 100%, 50%)`                   |
+| `glsl`   | `vec3(1.0, 0.4, 0.0)`                | `vec3(1.000, 0.400, 0.000)`              |
+| `oklch`  | `oklch(65% 0.196 41)`                | `oklch(69.58% 0.2043 43.49)`             |
+| `oklab`  | `oklab(65% 0.1 0.1)`                 | `oklab(65.00% 0.1000 0.1000)`            |
+| `p3`     | `color(display-p3 1 0.4 0)`          | `color(display-p3 1.0000 0.4000 0.0000)` |
+
+**GLSL:** outputs `vec3` when the source has no alpha channel, `vec4` when it does (e.g. 8-digit hex `#rrggbbaa`).
+
+## Examples
+
+```bash
+# Hex to RGB (format auto-detected)
+pigment "#ff6600" --to rgb
+# rgb(255, 102, 0)
+
+# Hex to OKLCH (format auto-detected)
+pigment "#ff6600" --to oklch
+# oklch(0.6958 0.2043 43.49)
+
+# 8-digit hex to GLSL vec4 (with alpha, format auto-detected)
+pigment "#ff660080" --to glsl
+# vec4(1.000, 0.400, 0.000, 0.502)
+
+# RGB to HSL (explicit --from)
+pigment "rgb(255, 102, 0)" --from rgb --to hsl
+# hsl(24, 100%, 50%)
+
+# OKLCH to Display P3 (explicit --from)
+pigment "oklch(0.65 0.196 41)" --from oklch --to p3
+# color(display-p3 0.8588 0.3860 0.1713)
+
+# GLSL to hex (explicit --from)
+pigment "vec3(1.0, 0.4, 0.0)" --from glsl --to hex
+# #ff6600
+```
+
+## Flags
+
+| Flag     | Alias | Description                             |
+|----------|-------|-----------------------------------------|
+| `--from` | `-f`  | Input format (auto-detected if omitted) |
+| `--to`   | `-t`  | Output format (required)                |
+| `--help` | `-h`  | Show help                               |
+
+## Build
+
+```bash
+yarn build
+```
+
+Outputs to `dist/index.js`.
+
+## Acknowledgements
+
+Color space conversions by [`@texel/color`](https://github.com/texel-org/color).

package/dist/index.js

@@ -0,0 +1,272 @@
+// src/index.ts
+import yargs from "yargs";
+
+// src/converters.ts
+import {
+  convert as colorConvert,
+  deserialize,
+  sRGB,
+  OKLab,
+  OKLCH,
+  DisplayP3
+} from "@texel/color";
+var FORMATS = ["hex", "rgb", "hsl", "glsl", "oklch", "oklab", "p3"];
+function hslToSRGB(h, s, l) {
+  if (s === 0) return [l, l, l];
+  const hue2rgb = (p2, q2, t) => {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+    if (t < 1 / 2) return q2;
+    if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+    return p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  return [hue2rgb(p, q, h + 1 / 3), hue2rgb(p, q, h), hue2rgb(p, q, h - 1 / 3)];
+}
+function sRGBToHSL(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return [0, 0, l];
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h = 0;
+  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  else if (max === g) h = ((b - r) / d + 2) / 6;
+  else h = ((r - g) / d + 4) / 6;
+  return [h, s, l];
+}
+function detectFormat(color2) {
+  const s = color2.trim().toLowerCase();
+  if (s.startsWith("#")) return "hex";
+  if (s.startsWith("rgba(") || s.startsWith("rgb(")) return "rgb";
+  if (s.startsWith("hsla(") || s.startsWith("hsl(")) return "hsl";
+  if (s.startsWith("vec3(") || s.startsWith("vec4(")) return "glsl";
+  if (s.startsWith("oklch(")) return "oklch";
+  if (s.startsWith("oklab(")) return "oklab";
+  if (s.startsWith("color(display-p3")) return "p3";
+  throw new Error(`Cannot detect format for: ${color2}`);
+}
+function parse(color2, from) {
+  switch (from) {
+    case "hex": {
+      const hex = color2.replace(/^#/, "");
+      const len = hex.length;
+      if (len === 3) {
+        return {
+          values: [
+            parseInt(hex[0] + hex[0], 16) / 255,
+            parseInt(hex[1] + hex[1], 16) / 255,
+            parseInt(hex[2] + hex[2], 16) / 255
+          ],
+          hasAlpha: false
+        };
+      }
+      if (len === 4) {
+        return {
+          values: [
+            parseInt(hex[0] + hex[0], 16) / 255,
+            parseInt(hex[1] + hex[1], 16) / 255,
+            parseInt(hex[2] + hex[2], 16) / 255,
+            parseInt(hex[3] + hex[3], 16) / 255
+          ],
+          hasAlpha: true
+        };
+      }
+      if (len === 6) {
+        return {
+          values: [
+            parseInt(hex.slice(0, 2), 16) / 255,
+            parseInt(hex.slice(2, 4), 16) / 255,
+            parseInt(hex.slice(4, 6), 16) / 255
+          ],
+          hasAlpha: false
+        };
+      }
+      if (len === 8) {
+        return {
+          values: [
+            parseInt(hex.slice(0, 2), 16) / 255,
+            parseInt(hex.slice(2, 4), 16) / 255,
+            parseInt(hex.slice(4, 6), 16) / 255,
+            parseInt(hex.slice(6, 8), 16) / 255
+          ],
+          hasAlpha: true
+        };
+      }
+      throw new Error(`Invalid hex color: ${color2}`);
+    }
+    case "rgb": {
+      const m = color2.match(/rgba?\(\s*([^)]+)\)/i);
+      if (!m) throw new Error(`Invalid rgb color: ${color2}`);
+      const parts = m[1].split(",").map((s) => s.trim());
+      const r = parseInt(parts[0]) / 255;
+      const g = parseInt(parts[1]) / 255;
+      const b = parseInt(parts[2]) / 255;
+      if (parts.length === 4) {
+        return { values: [r, g, b, parseFloat(parts[3])], hasAlpha: true };
+      }
+      return { values: [r, g, b], hasAlpha: false };
+    }
+    case "hsl": {
+      const m = color2.match(/hsla?\(\s*([^)]+)\)/i);
+      if (!m) throw new Error(`Invalid hsl color: ${color2}`);
+      const parts = m[1].split(",").map((s2) => s2.trim());
+      const h = parseFloat(parts[0]) / 360;
+      const s = parseFloat(parts[1]) / 100;
+      const l = parseFloat(parts[2]) / 100;
+      const rgb = hslToSRGB(h, s, l);
+      if (parts.length === 4) {
+        return { values: [...rgb, parseFloat(parts[3])], hasAlpha: true };
+      }
+      return { values: rgb, hasAlpha: false };
+    }
+    case "glsl": {
+      const m = color2.match(/vec([34])\(\s*([^)]+)\)/);
+      if (!m) throw new Error(`Invalid glsl color: ${color2}`);
+      const isVec4 = m[1] === "4";
+      const components = m[2].split(",").map((s) => parseFloat(s.trim()));
+      return { values: components, hasAlpha: isVec4 };
+    }
+    case "oklch": {
+      const result = deserialize(color2);
+      const srgb = colorConvert(
+        result.coords,
+        OKLCH,
+        sRGB
+      );
+      return { values: Array.from(srgb), hasAlpha: false };
+    }
+    case "oklab": {
+      const result = deserialize(color2);
+      const srgb = colorConvert(
+        result.coords,
+        OKLab,
+        sRGB
+      );
+      return { values: Array.from(srgb), hasAlpha: false };
+    }
+    case "p3": {
+      const result = deserialize(color2);
+      const srgb = colorConvert(
+        result.coords,
+        DisplayP3,
+        sRGB
+      );
+      return { values: Array.from(srgb), hasAlpha: false };
+    }
+  }
+}
+function convertToSpace(srgbValues, to) {
+  const alpha = srgbValues.length === 4 ? srgbValues[3] : void 0;
+  const rgb3 = [srgbValues[0], srgbValues[1], srgbValues[2]];
+  const converted = (() => {
+    switch (to) {
+      case "hex":
+      case "rgb":
+      case "glsl":
+        return Array.from(rgb3);
+      case "hsl":
+        return Array.from(sRGBToHSL(rgb3[0], rgb3[1], rgb3[2]));
+      case "oklch":
+        return Array.from(colorConvert(rgb3, sRGB, OKLCH));
+      case "oklab":
+        return Array.from(colorConvert(rgb3, sRGB, OKLab));
+      case "p3":
+        return Array.from(colorConvert(rgb3, sRGB, DisplayP3));
+    }
+  })();
+  if (alpha !== void 0) converted.push(alpha);
+  return converted;
+}
+function serialize(values, to, hasAlpha) {
+  const [c0, c1, c2, c3] = values;
+  switch (to) {
+    case "hex": {
+      const r = Math.round(c0 * 255).toString(16).padStart(2, "0");
+      const g = Math.round(c1 * 255).toString(16).padStart(2, "0");
+      const b = Math.round(c2 * 255).toString(16).padStart(2, "0");
+      if (hasAlpha && c3 !== void 0) {
+        const a = Math.round(c3 * 255).toString(16).padStart(2, "0");
+        return `#${r}${g}${b}${a}`;
+      }
+      return `#${r}${g}${b}`;
+    }
+    case "rgb": {
+      const r = Math.round(c0 * 255);
+      const g = Math.round(c1 * 255);
+      const b = Math.round(c2 * 255);
+      if (hasAlpha && c3 !== void 0) return `rgba(${r}, ${g}, ${b}, ${c3.toFixed(3)})`;
+      return `rgb(${r}, ${g}, ${b})`;
+    }
+    case "hsl": {
+      const h = Math.round(c0 * 360);
+      const s = Math.round(c1 * 100);
+      const l = Math.round(c2 * 100);
+      if (hasAlpha && c3 !== void 0) return `hsla(${h}, ${s}%, ${l}%, ${c3.toFixed(3)})`;
+      return `hsl(${h}, ${s}%, ${l}%)`;
+    }
+    case "glsl": {
+      const r = c0.toFixed(3);
+      const g = c1.toFixed(3);
+      const b = c2.toFixed(3);
+      if (hasAlpha && c3 !== void 0) return `vec4(${r}, ${g}, ${b}, ${c3.toFixed(3)})`;
+      return `vec3(${r}, ${g}, ${b})`;
+    }
+    case "oklch": {
+      const L = c0.toFixed(4);
+      const C = c1.toFixed(4);
+      const H = c2.toFixed(2);
+      if (hasAlpha && c3 !== void 0) return `oklch(${L} ${C} ${H} / ${c3.toFixed(3)})`;
+      return `oklch(${L} ${C} ${H})`;
+    }
+    case "oklab": {
+      const L = c0.toFixed(4);
+      const a = c1.toFixed(4);
+      const b = c2.toFixed(4);
+      if (hasAlpha && c3 !== void 0) return `oklab(${L} ${a} ${b} / ${c3.toFixed(3)})`;
+      return `oklab(${L} ${a} ${b})`;
+    }
+    case "p3": {
+      const r = c0.toFixed(4);
+      const g = c1.toFixed(4);
+      const b = c2.toFixed(4);
+      if (hasAlpha && c3 !== void 0) return `color(display-p3 ${r} ${g} ${b} / ${c3.toFixed(3)})`;
+      return `color(display-p3 ${r} ${g} ${b})`;
+    }
+  }
+}
+
+// src/index.ts
+var argv = await yargs(process.argv.slice(2)).usage("$0 <color> [options]").positional("color", {
+  type: "string",
+  description: "Input color value"
+}).option("from", {
+  alias: "f",
+  type: "string",
+  description: "Input format (auto-detected if omitted)",
+  choices: FORMATS
+}).option("to", {
+  alias: "t",
+  type: "string",
+  description: "Output format",
+  choices: FORMATS,
+  demandOption: true
+}).help().alias("help", "h").parseAsync();
+var color = argv._[0];
+if (!color) {
+  console.error("Missing required argument: color");
+  process.exit(1);
+}
+try {
+  const from = argv.from ?? detectFormat(color);
+  const { values, hasAlpha } = parse(color, from);
+  const converted = convertToSpace(values, argv.to);
+  const output = serialize(converted, argv.to, hasAlpha);
+  console.log(output);
+} catch (e) {
+  console.error(e.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@andbc/pigment",
+  "version": "0.0.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "A CLI tool to convert colors between different formats (HEX, RGB, HSL, etc.)",
+  "type": "module",
+  "bin": {
+    "pigment": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "main": "index.js",
+  "scripts": {
+    "watch": "tsup ./src/index.ts --format esm --watch",
+    "build": "tsc --noemit && tsup ./src/index.ts --format esm",
+    "prepublishOnly": "npm run build"
+  },
+  "author": "Andy Duboc",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.0.8",
+    "@types/yargs": "^17.0.35",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@texel/color": "^1.1.11",
+    "yargs": "17.7.2"
+  }
+}