@basiclines/rampa 1.3.0 → 1.4.0

package/dist/index.js

@@ -9869,8 +9869,32 @@ function isValidOutputFormat(format) {
 }
 
 // src/formatters/json.ts
-function formatJson(ramps) {
-  return JSON.stringify({ ramps }, null, 2);
+function structuredColor(hex6, format) {
+  const c4 = chroma_js_default(hex6);
+  const [r4, g3, b2] = c4.rgb();
+  const [hh, ss, ll] = c4.hsl();
+  const [ol, oc, oh] = c4.oklch();
+  const all = {
+    hex: c4.hex(),
+    rgb: { r: r4, g: g3, b: b2 },
+    hsl: { h: Math.round(hh || 0), s: Math.round(ss * 100), l: Math.round(ll * 100) },
+    oklch: { l: parseFloat((ol * 100).toFixed(1)), c: parseFloat(oc.toFixed(3)), h: Math.round(oh || 0) }
+  };
+  if (format) {
+    return { [format]: all[format] };
+  }
+  return all;
+}
+function formatJson(ramps, format) {
+  const output = {
+    ramps: ramps.map((ramp) => ({
+      name: ramp.name,
+      baseColor: ramp.baseColor,
+      config: ramp.config,
+      colors: (ramp.rawColors || ramp.colors).map((c4) => structuredColor(c4, format))
+    }))
+  };
+  return JSON.stringify(output, null, 2);
 }
 
 // src/formatters/css.ts
@@ -10229,7 +10253,8 @@ function formatAccessibilityCss(report) {
 }
 
 // src/index.ts
-if (process.argv.includes("--help") || process.argv.includes("-h")) {
+var args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h") || args.includes("help") || args.length === 0) {
   showHelp();
 }
 function showHelp() {
@@ -10237,7 +10262,7 @@ function showHelp() {
   const dim = "\x1B[2m";
   const reset = "\x1B[0m";
   const help = `
-rampa v1.2.0
+rampa v1.4.0
 Generate mathematically accurate color palettes from a base color
 
 USAGE
@@ -10246,7 +10271,11 @@ USAGE
 BASE
   ${cyan}-C, --color <color>${reset}            ${dim}Base color (required)${reset}
   ${cyan}--size <number>${reset}                ${dim}Number of colors in palette (2-100, default: 10)${reset}
-  ${cyan}-F, --format <type>${reset}            ${dim}Color format: hex, hsl, rgb, oklch (default: auto)${reset}
+
+FORMAT
+  ${cyan}-F, --format <type>${reset}            ${dim}Color format for output values (default: same as input)${reset}
+
+                                  ${dim}Types: hex, hsl, rgb, oklch${reset}
 
 RANGES
   ${cyan}-L, --lightness <start:end>${reset}    ${dim}Lightness range 0-100 (default: 0:100)${reset}
@@ -10279,27 +10308,44 @@ HARMONIES
 
 OUTPUT
   ${cyan}-O, --output <format>${reset}          ${dim}Output format (default: text)${reset}
+
+                                  ${dim}Formats: text, json, css${reset}
+
   ${cyan}--preview / --no-preview${reset}       ${dim}Show colored squares (default: true)${reset}
-  ${cyan}-A, --accessibility [filter]${reset}    ${dim}Show APCA contrast report${reset}
+
+ACCESSIBILITY
+  ${cyan}-A, --accessibility [filter]${reset}   ${dim}Show APCA contrast report${reset}
 
                                   ${dim}Filters: preferred, body, large, bold, minimum, nontext${reset}
                                   ${dim}or a custom Lc value (e.g. 60)${reset}
 
-                                  ${dim}Formats: text, json, css${reset}
+COLOR CONVERSION
+  ${cyan}--read-only${reset}                    ${dim}Output the input color without generating a ramp${reset}
+
+                                  ${dim}Use with --color to specify the input color.${reset}
+                                  ${dim}Use with --format to convert to a specific format.${reset}
+                                  ${dim}Use with --output to choose text, json, or css.${reset}
+
+                                  ${dim}Without --format: outputs all formats (hex, hsl, rgb, oklch)${reset}
+                                  ${dim}With --format: outputs only the specified format${reset}
+                                  ${dim}JSON output returns structured values, not strings${reset}
 
 OTHER
   ${cyan}-h, --help${reset}                     ${dim}Show this help${reset}
   ${cyan}-v, --version${reset}                  ${dim}Show version${reset}
 
 EXAMPLES
-  ${cyan}rampa -C "#3b82f6"${reset}
-  ${cyan}rampa -C "#3b82f6" --size=5 -L 10:90${reset}
-  ${cyan}rampa -C "#3b82f6" --add=complementary --add=triadic${reset}
-  ${cyan}rampa -C "#3b82f6" --add=shift:45 --add=shift:90${reset}
-  ${cyan}rampa -C "#3b82f6" -O css${reset}
-  ${cyan}rampa -C "#3b82f6" --tint-color="#FF0000" --tint-opacity=15${reset}
-  ${cyan}rampa -C "#3b82f6" -A${reset}
-  ${cyan}rampa -C "#3b82f6" --add=complementary -O json -A${reset}
+  ${cyan}rampa --color "#3b82f6"${reset}
+  ${cyan}rampa --color "#3b82f6" --size=5 --lightness 10:90${reset}
+  ${cyan}rampa --color "#3b82f6" --add=complementary --add=triadic${reset}
+  ${cyan}rampa --color "#3b82f6" --add=shift:45 --add=shift:90${reset}
+  ${cyan}rampa --color "#3b82f6" --output css${reset}
+  ${cyan}rampa --color "#3b82f6" --tint-color="#FF0000" --tint-opacity=15${reset}
+  ${cyan}rampa --color "#3b82f6" --accessibility${reset}
+  ${cyan}rampa --color "#3b82f6" --add=complementary --output json --accessibility${reset}
+  ${cyan}rampa --color "#fe0000" --read-only${reset}
+  ${cyan}rampa --color "#fe0000" --read-only --format hsl${reset}
+  ${cyan}rampa --color "#fe0000" --read-only --format hsl --output json${reset}
 `;
   console.log(help.trim());
   process.exit(0);
@@ -10458,6 +10504,19 @@ Examples:
   rampa -C "#3b82f6" -A=large
   rampa -C "#3b82f6" --accessibility=75
   rampa -C "#3b82f6" -O json -A preferred
+`,
+  "read-only": `
+--read-only  Output the input color converted to the target format (no ramp)
+
+When --format is specified, outputs the color in that format.
+When --format is omitted, outputs all formats (hex, hsl, rgb, oklch).
+
+Examples:
+  rampa -C "#fe0000" --read-only
+  rampa -C "#fe0000" --read-only -F hsl
+  rampa -C "#fe0000" --read-only -O json
+  rampa -C "#fe0000" --read-only -O json -F hsl
+  rampa -C "#fe0000" --read-only -O css -F rgb
 `
 };
 function showFlagHelp(flag) {
@@ -10496,11 +10555,23 @@ function formatColor2(color, format) {
       return c4.hex();
   }
 }
+function formatColorStructured(color) {
+  const c4 = chroma_js_default(color);
+  const [r4, g3, b2] = c4.rgb();
+  const [hh, ss, ll] = c4.hsl();
+  const [ol, oc, oh] = c4.oklch();
+  return {
+    hex: c4.hex(),
+    rgb: { r: r4, g: g3, b: b2 },
+    hsl: { h: Math.round(hh || 0), s: Math.round(ss * 100), l: Math.round(ll * 100) },
+    oklch: { l: parseFloat((ol * 100).toFixed(1)), c: parseFloat(oc.toFixed(3)), h: Math.round(oh || 0) }
+  };
+}
 var validFormats = ["hex", "hsl", "rgb", "oklch"];
 var main = defineCommand({
   meta: {
     name: "rampa",
-    version: "1.3.0",
+    version: "1.4.0",
     description: "Generate mathematically accurate color palettes from a base color"
   },
   args: {
@@ -10586,79 +10657,123 @@ var main = defineCommand({
       type: "string",
       alias: ["A", "a"],
       description: "Show APCA contrast report. Optional: filter by level name or Lc value"
+    },
+    "read-only": {
+      type: "boolean",
+      description: "Output the input color converted to the target format without generating a ramp",
+      default: false
     }
   },
-  run({ args }) {
-    if (needsHelp(args.size) && args.size !== "10")
+  run({ args: args2 }) {
+    if (needsHelp(args2.size) && args2.size !== "10")
       showFlagHelp("size");
-    if (args.format !== undefined && needsHelp(args.format))
+    if (args2.format !== undefined && needsHelp(args2.format))
       showFlagHelp("format");
-    if (needsHelp(args.lightness) && args.lightness !== "0:100")
+    if (needsHelp(args2.lightness) && args2.lightness !== "0:100")
       showFlagHelp("lightness");
-    if (needsHelp(args.saturation) && args.saturation !== "100:0")
+    if (needsHelp(args2.saturation) && args2.saturation !== "100:0")
       showFlagHelp("saturation");
-    if (needsHelp(args.hue) && args.hue !== "-10:10")
+    if (needsHelp(args2.hue) && args2.hue !== "-10:10")
       showFlagHelp("hue");
-    if (needsHelp(args["lightness-scale"]) && args["lightness-scale"] !== "linear")
+    if (needsHelp(args2["lightness-scale"]) && args2["lightness-scale"] !== "linear")
       showFlagHelp("lightness-scale");
-    if (needsHelp(args["saturation-scale"]) && args["saturation-scale"] !== "linear")
+    if (needsHelp(args2["saturation-scale"]) && args2["saturation-scale"] !== "linear")
       showFlagHelp("saturation-scale");
-    if (needsHelp(args["hue-scale"]) && args["hue-scale"] !== "linear")
+    if (needsHelp(args2["hue-scale"]) && args2["hue-scale"] !== "linear")
       showFlagHelp("hue-scale");
-    if (args["tint-color"] !== undefined && needsHelp(args["tint-color"]))
+    if (args2["tint-color"] !== undefined && needsHelp(args2["tint-color"]))
       showFlagHelp("tint-color");
-    if (needsHelp(args["tint-opacity"]) && args["tint-opacity"] !== "0")
+    if (needsHelp(args2["tint-opacity"]) && args2["tint-opacity"] !== "0")
       showFlagHelp("tint-opacity");
-    if (needsHelp(args["tint-blend"]) && args["tint-blend"] !== "normal")
+    if (needsHelp(args2["tint-blend"]) && args2["tint-blend"] !== "normal")
       showFlagHelp("tint-blend");
-    if (args.add !== undefined && needsHelp(args.add))
+    if (args2.add !== undefined && needsHelp(args2.add))
       showFlagHelp("add");
-    if (needsHelp(args.output) && args.output !== "text")
+    if (needsHelp(args2.output) && args2.output !== "text")
       showFlagHelp("output");
-    const detectedFormat = detectColorFormat(args.color);
+    const detectedFormat = detectColorFormat(args2.color);
     let validatedColor;
     try {
-      validatedColor = chroma_js_default(args.color).hex();
+      validatedColor = chroma_js_default(args2.color).hex();
     } catch {
       showFlagHelp("color");
     }
-    const size = parseInt(args.size, 10);
+    const size = parseInt(args2.size, 10);
     if (isNaN(size) || size < 2 || size > 100) {
-      console.error(`Error: Size must be a number between 2 and 100, got "${args.size}"
+      console.error(`Error: Size must be a number between 2 and 100, got "${args2.size}"
 `);
       showFlagHelp("size");
     }
-    const outputFormat = args.format?.toLowerCase() || detectedFormat;
-    if (!validFormats.includes(outputFormat)) {
-      console.error(`Error: Invalid format "${args.format}"
+    const outputFormat = args2.format?.toLowerCase() || detectedFormat;
+    if (args2.format && !validFormats.includes(outputFormat)) {
+      console.error(`Error: Invalid format "${args2.format}"
 `);
       showFlagHelp("format");
     }
+    if (args2["read-only"]) {
+      const outputType2 = args2.output;
+      if (!isValidOutputFormat(outputType2)) {
+        console.error(`Error: Invalid output format "${outputType2}"
+`);
+        showFlagHelp("output");
+      }
+      const hasExplicitFormat = !!args2.format;
+      if (hasExplicitFormat) {
+        const converted = formatColor2(validatedColor, outputFormat);
+        if (outputType2 === "json") {
+          const structured = formatColorStructured(validatedColor);
+          console.log(JSON.stringify({ color: { value: converted, [outputFormat]: structured[outputFormat] } }, null, 2));
+        } else if (outputType2 === "css") {
+          console.log(`:root {
+  --color: ${converted};
+}`);
+        } else {
+          console.log(converted);
+        }
+      } else {
+        if (outputType2 === "json") {
+          console.log(JSON.stringify({ color: formatColorStructured(validatedColor) }, null, 2));
+        } else if (outputType2 === "css") {
+          const lines = [":root {"];
+          for (const fmt of validFormats) {
+            lines.push(`  --color-${fmt}: ${formatColor2(validatedColor, fmt)};`);
+          }
+          lines.push("}");
+          console.log(lines.join(`
+`));
+        } else {
+          for (const fmt of validFormats) {
+            console.log(`${fmt}: ${formatColor2(validatedColor, fmt)}`);
+          }
+        }
+      }
+      return;
+    }
     let lightness, saturation, hue3;
     try {
-      lightness = parsePercentRange(args.lightness, "lightness");
+      lightness = parsePercentRange(args2.lightness, "lightness");
     } catch (e4) {
       console.error(`Error: ${e4.message}
 `);
       showFlagHelp("lightness");
     }
     try {
-      saturation = parsePercentRange(args.saturation, "saturation");
+      saturation = parsePercentRange(args2.saturation, "saturation");
     } catch (e4) {
       console.error(`Error: ${e4.message}
 `);
       showFlagHelp("saturation");
     }
     try {
-      hue3 = parseHueRange(args.hue);
+      hue3 = parseHueRange(args2.hue);
     } catch (e4) {
       console.error(`Error: ${e4.message}
 `);
       showFlagHelp("hue");
     }
-    const lightnessScale = args["lightness-scale"];
-    const saturationScale = args["saturation-scale"];
-    const hueScale = args["hue-scale"];
+    const lightnessScale = args2["lightness-scale"];
+    const saturationScale = args2["saturation-scale"];
+    const hueScale = args2["hue-scale"];
     if (!isValidScaleType(lightnessScale)) {
       console.error(`Error: Invalid lightness-scale "${lightnessScale}"
 `);
@@ -10674,9 +10789,9 @@ var main = defineCommand({
 `);
       showFlagHelp("hue-scale");
     }
-    const tintColor = args["tint-color"];
-    const tintOpacity = parseInt(args["tint-opacity"], 10);
-    const tintBlend = args["tint-blend"];
+    const tintColor = args2["tint-color"];
+    const tintOpacity = parseInt(args2["tint-opacity"], 10);
+    const tintBlend = args2["tint-blend"];
     let validatedTintColor;
     if (tintColor) {
       try {
@@ -10688,7 +10803,7 @@ var main = defineCommand({
       }
     }
     if (isNaN(tintOpacity) || tintOpacity < 0 || tintOpacity > 100) {
-      console.error(`Error: tint-opacity must be between 0 and 100, got "${args["tint-opacity"]}"
+      console.error(`Error: tint-opacity must be between 0 and 100, got "${args2["tint-opacity"]}"
 `);
       showFlagHelp("tint-opacity");
     }
@@ -10697,7 +10812,7 @@ var main = defineCommand({
 `);
       showFlagHelp("tint-blend");
     }
-    const addValues = args.add ? Array.isArray(args.add) ? args.add : [args.add] : [];
+    const addValues = args2.add ? Array.isArray(args2.add) ? args2.add : [args2.add] : [];
     const harmonies = [];
     const hueShifts = [];
     for (const value of addValues) {
@@ -10730,7 +10845,7 @@ var main = defineCommand({
     if (!tintColor && tintBlend !== "normal") {
       console.error("Warning: --tint-blend has no effect without --tint-color");
     }
-    const outputType = args.output;
+    const outputType = args2.output;
     if (!isValidOutputFormat(outputType)) {
       console.error(`Error: Invalid output format "${outputType}"
 `);
@@ -10795,7 +10910,8 @@ var main = defineCommand({
       name: "base",
       baseColor: formatColor2(validatedColor, outputFormat),
       config: buildRampConfig(),
-      colors: formattedBaseColors
+      colors: formattedBaseColors,
+      rawColors: baseColors
     });
     for (const harmony of harmonies) {
       const harmonyColors = getHarmonyColors(harmony, validatedColor);
@@ -10807,7 +10923,8 @@ var main = defineCommand({
           name: `${harmony}${suffix}`,
           baseColor: formatColor2(harmonyBaseColor, outputFormat),
           config: buildRampConfig(),
-          colors: formattedHarmonyColors
+          colors: formattedHarmonyColors,
+          rawColors: harmonyRampColors
         });
       });
     }
@@ -10822,18 +10939,20 @@ var main = defineCommand({
         name: `shift-${Math.round(shift)}`,
         baseColor: formatColor2(shiftedBaseColor, outputFormat),
         config: buildRampConfig(),
-        colors: formattedShiftedColors
+        colors: formattedShiftedColors,
+        rawColors: shiftedRampColors
       });
     }
-    const accessibilityEnabled = args.accessibility !== undefined;
-    const accessibilityFilter = accessibilityEnabled ? parseAccessibilityFilter(args.accessibility) : undefined;
+    const accessibilityEnabled = args2.accessibility !== undefined;
+    const accessibilityFilter = accessibilityEnabled ? parseAccessibilityFilter(args2.accessibility) : undefined;
+    const jsonFormat = args2.format ? outputFormat : undefined;
     if (outputType === "json") {
       if (accessibilityEnabled) {
         const report = generateAccessibilityReport(ramps, accessibilityFilter);
-        const output = { ramps: JSON.parse(formatJson(ramps)).ramps, accessibility: formatAccessibilityJson(report) };
+        const output = { ramps: JSON.parse(formatJson(ramps, jsonFormat)).ramps, accessibility: formatAccessibilityJson(report) };
         console.log(JSON.stringify(output, null, 2));
       } else {
-        console.log(formatJson(ramps));
+        console.log(formatJson(ramps, jsonFormat));
       }
     } else if (outputType === "css") {
       let output = formatCss2(ramps);
@@ -10843,8 +10962,8 @@ var main = defineCommand({
       }
       console.log(output);
     } else {
-      const canShowPreview = args.preview && supportsTruecolor();
-      if (args.preview && !canShowPreview) {
+      const canShowPreview = args2.preview && supportsTruecolor();
+      if (args2.preview && !canShowPreview) {
         const limitationNote = getColorLimitationNote();
         if (limitationNote) {
           console.log(limitationNote);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basiclines/rampa",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Generate mathematically accurate color palettes from a base color",
   "type": "module",
   "bin": {