quick-palette 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryo Sugimoto
+
+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,107 @@
+# Quick Palette
+
+Explore reproducible OKLCH-based color palettes from the command line. The default flow shows a usable five-step palette after one selection, then lets you accept it or move to another candidate with one key.
+
+## Quick start
+
+```bash
+pnpm dlx quick-palette
+```
+
+Or use npm:
+
+```bash
+npx quick-palette
+```
+
+Press Enter to choose **Explore random palettes**. In the exploration view:
+
+```text
+Enter: accept   Space: next   e: edit   q: quit
+```
+
+Every candidate displays a seed. Accepting prints concise HEX output without asking about step counts or export formats.
+
+## Reproduce a palette
+
+Use the seed shown below an exploration preview:
+
+```bash
+pnpm dlx quick-palette generate --seed 8f3a21c4
+```
+
+The same seed produces the same configuration and palette within the same Quick Palette version. Save the generated JSON output when exact colors must be retained across versions. JSON and CSS output are available without interactive prompts:
+
+```bash
+pnpm dlx quick-palette generate --seed 8f3a21c4 --format json
+pnpm dlx quick-palette generate --seed 8f3a21c4 --format css --output palette.css
+```
+
+Non-interactive output goes only to stdout unless `--output` is supplied. Errors go to stderr and set a non-zero exit status.
+
+## Generate an exact configuration
+
+```bash
+pnpm dlx quick-palette generate \
+  --base '#2563EB' \
+  --harmony analogous \
+  --tuning ui \
+  --neutral tinted \
+  --color-steps 5 \
+  --neutral-steps 5 \
+  --format json
+```
+
+Supported values:
+
+- Harmony: `monochrome`, `analogous`, `complementary`, `triadic`
+- Tuning: `mechanical`, `ui`, `branding`, `data-visualization`
+- Neutrals: `neutral`, `tinted`
+- Step counts: `3`, `5`, `7`, `9`
+- Formats: `hex`, `json`, `css`
+
+Run `pnpm dlx quick-palette --help` for the complete command reference. For repeated use, install it globally with `npm install --global quick-palette` and run `quick-palette` directly.
+
+## Detailed configuration
+
+Choose **Create a custom palette** at startup, or run:
+
+```bash
+pnpm dlx quick-palette configure
+```
+
+The detailed flow selects a base color, harmony, harmony adjustment, and neutral style before showing a preview. Monochrome palettes skip the adjustment question because it would not change their colors. Its final actions are:
+
+- **Finish and print HEX values** prints HEX and exits with the current scales.
+- **Export as JSON or CSS** prints or saves a file, then lets you finish, export another format, or return to the palette.
+- **Change palette settings** changes the base color, harmony, neutral style, or step counts while preserving other values.
+
+Press `e` during exploration to open the field picker directly with the current candidate values preselected.
+
+## Palette choices
+
+### Base color
+
+Enter `#RGB` or `#RRGGBB`, or select a curated color by family, mood, or use case. Random exploration also draws from the deduplicated curated color set.
+
+### Harmony
+
+- **Monochrome (1 hue + neutrals)** keeps the palette focused.
+- **Analogous (3 neighboring hues + neutrals)** creates cohesive variety.
+- **Complementary (2 opposite hues + neutrals)** creates clear contrast.
+- **Triadic (3 evenly spaced hues + neutrals)** creates colorful balance.
+
+### Harmony adjustment
+
+- **Fixed angles** preserves predictable color-theory angles.
+- **UI** favors restrained screen accents.
+- **Branding** favors vivid, separated accents.
+- **Data visualization** prioritizes categorical separation.
+
+Adjustments are deterministic and bounded to 12 degrees from each fixed harmony angle. Monochrome palettes do not ask for an adjustment because they contain no secondary hue.
+
+### Neutrals and steps
+
+Neutral gray has zero chroma. Base-tinted gray carries a small amount of the base hue into backgrounds, borders, and text colors.
+
+Colors and neutrals default to five lightness steps. Terminal output labels them from `100` to `900` in light-to-dark order, matching CSS output. Wider harmonies display one separately labeled scale per hue. Use **Change palette settings > Step counts** or non-interactive flags when 3, 7, or 9 steps are needed.

package/dist/cli/args.js

@@ -0,0 +1,128 @@
+import { normalizeHex } from "../core/color.js";
+import { HARMONY_MODES, HARMONY_TUNINGS, NEUTRAL_MODES, STEP_COUNTS, } from "../core/types.js";
+export class CliArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CliArgumentError";
+    }
+}
+export function parseCliArgs(args) {
+    if (args.length === 0)
+        return { name: "interactive" };
+    if (args.includes("--help") || args.includes("-h"))
+        return { name: "help" };
+    const [command, ...options] = args;
+    if (command === "configure") {
+        if (options.length > 0)
+            throw new CliArgumentError("The configure command does not accept options.");
+        return { name: "configure" };
+    }
+    if (command === "explore")
+        return parseExploreOptions(options);
+    if (command === "generate")
+        return parseGenerateOptions(options);
+    throw new CliArgumentError(`Unknown command: ${command}`);
+}
+function parseExploreOptions(args) {
+    const values = parseOptionValues(args, new Set(["--seed"]));
+    const seed = values.get("--seed");
+    return seed === undefined ? { name: "explore" } : { name: "explore", seed };
+}
+function parseGenerateOptions(args) {
+    const values = parseOptionValues(args, new Set([
+        "--seed",
+        "--base",
+        "--harmony",
+        "--tuning",
+        "--neutral",
+        "--color-steps",
+        "--neutral-steps",
+        "--format",
+        "--output",
+    ]));
+    const format = parseChoice(values.get("--format") ?? "hex", "format", ["hex", "json", "css"]);
+    const base = values.get("--base");
+    const seed = values.get("--seed");
+    const harmony = optionalChoice(values.get("--harmony"), "harmony", HARMONY_MODES);
+    const harmonyTuning = optionalChoice(values.get("--tuning"), "tuning", HARMONY_TUNINGS);
+    const neutralMode = optionalChoice(values.get("--neutral"), "neutral mode", NEUTRAL_MODES);
+    const colorSteps = optionalStepCount(values.get("--color-steps"), "color steps");
+    const neutralSteps = optionalStepCount(values.get("--neutral-steps"), "neutral steps");
+    const outputPath = values.get("--output");
+    return {
+        name: "generate",
+        ...(seed === undefined ? {} : { seed }),
+        ...(base === undefined ? {} : { baseColor: parseBaseColor(base) }),
+        ...(harmony === undefined ? {} : { harmony }),
+        ...(harmonyTuning === undefined ? {} : { harmonyTuning }),
+        ...(neutralMode === undefined ? {} : { neutralMode }),
+        ...(colorSteps === undefined ? {} : { colorSteps }),
+        ...(neutralSteps === undefined ? {} : { neutralSteps }),
+        format,
+        ...(outputPath === undefined ? {} : { outputPath }),
+    };
+}
+function parseOptionValues(args, allowed) {
+    const values = new Map();
+    for (let index = 0; index < args.length; index += 2) {
+        const option = args[index];
+        const value = args[index + 1];
+        if (option === undefined || !allowed.has(option)) {
+            throw new CliArgumentError(`Unknown option: ${option ?? ""}`);
+        }
+        if (values.has(option))
+            throw new CliArgumentError(`Duplicate option: ${option}`);
+        if (value === undefined || value.startsWith("--")) {
+            throw new CliArgumentError(`Missing value for ${option}.`);
+        }
+        values.set(option, value);
+    }
+    return values;
+}
+function parseBaseColor(value) {
+    try {
+        return normalizeHex(value);
+    }
+    catch {
+        throw new CliArgumentError(`Invalid base color: ${value}`);
+    }
+}
+function optionalChoice(value, label, allowed) {
+    return value === undefined ? undefined : parseChoice(value, label, allowed);
+}
+function parseChoice(value, label, allowed) {
+    if (allowed.includes(value))
+        return value;
+    throw new CliArgumentError(`Invalid ${label}: ${value}. Expected ${allowed.join(", ")}.`);
+}
+function optionalStepCount(value, label) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (STEP_COUNTS.includes(parsed))
+        return parsed;
+    throw new CliArgumentError(`Invalid ${label}: ${value}. Expected ${STEP_COUNTS.join(", ")}.`);
+}
+export const HELP_TEXT = `Quick Palette
+
+Usage:
+  quick-palette
+  quick-palette explore [--seed <seed>]
+  quick-palette configure
+  quick-palette generate [options]
+  quick-palette --help
+
+Generate options:
+  --seed <seed>            Reproduce a randomized palette
+  --base <hex>             Base color (default: #2563EB)
+  --harmony <mode>         monochrome, analogous, complementary, or triadic
+  --tuning <purpose>       mechanical, ui, branding, or data-visualization
+  --neutral <mode>         neutral or tinted
+  --color-steps <count>    3, 5, 7, or 9 (default: 5)
+  --neutral-steps <count>  3, 5, 7, or 9 (default: 5)
+  --format <format>        hex, json, or css (default: hex)
+  --output <path>          Write output to a file instead of stdout
+
+Piping:
+  Non-interactive generate output is written only to stdout, or only to the
+  selected file with --output. Errors are written to stderr.`;

package/dist/cli/configure.js

@@ -0,0 +1,95 @@
+import { DEFAULT_COLOR_STEPS, DEFAULT_NEUTRAL_STEPS } from "../core/constants.js";
+import { generatePalette } from "../core/generate.js";
+import { formatHexOutput, writeCssOutput, writeJsonOutput } from "./output.js";
+import { promptBaseColor, promptConfigurationAction, promptConfigurationEditAction, promptExportCompleteAction, promptExportDestination, promptExportFormat, promptHarmony, promptHarmonyTuning, promptNeutralMode, promptStepCount, } from "./prompt.js";
+import { formatPreview } from "./preview.js";
+export async function configurePalette(prompt, useColor, initialConfig, dependencies = {}) {
+    const output = dependencies.output ?? console.log;
+    const writeJson = dependencies.writeJson ?? writeJsonOutput;
+    const writeCss = dependencies.writeCss ?? writeCssOutput;
+    let config = initialConfig ?? await promptInitialConfig(prompt);
+    if (dependencies.editImmediately)
+        config = await editConfig(prompt, config);
+    while (true) {
+        const result = generatePalette(config);
+        output(formatPreview(result, useColor));
+        while (true) {
+            const action = await promptConfigurationAction(prompt);
+            if (action === "accept") {
+                output(`\n${formatHexOutput(result, useColor)}`);
+                return result;
+            }
+            if (action === "edit") {
+                config = await editConfig(prompt, config);
+                break;
+            }
+            const exportAction = await exportPalette(prompt, result, writeJson, writeCss);
+            if (exportAction === "done")
+                return result;
+        }
+    }
+}
+async function promptInitialConfig(prompt) {
+    const baseColor = await promptBaseColor(prompt);
+    const harmony = await promptHarmony(prompt);
+    const harmonyTuning = harmony === "monochrome"
+        ? "mechanical"
+        : await promptHarmonyTuning(prompt);
+    return {
+        baseColor,
+        harmony,
+        harmonyTuning,
+        neutralMode: await promptNeutralMode(prompt),
+        colorSteps: DEFAULT_COLOR_STEPS,
+        neutralSteps: DEFAULT_NEUTRAL_STEPS,
+    };
+}
+async function editConfig(prompt, config) {
+    const action = await promptConfigurationEditAction(prompt);
+    if (action === "cancel")
+        return config;
+    if (action === "base") {
+        return { ...config, baseColor: await promptBaseColor(prompt, config.baseColor) };
+    }
+    if (action === "harmony") {
+        const harmony = await promptHarmony(prompt, config.harmony);
+        const harmonyTuning = harmony === "monochrome"
+            ? "mechanical"
+            : await promptHarmonyTuning(prompt, config.harmonyTuning ?? "mechanical");
+        return { ...config, harmony, harmonyTuning };
+    }
+    if (action === "neutral") {
+        const neutralMode = await promptNeutralMode(prompt, config.neutralMode);
+        return { ...config, neutralMode };
+    }
+    const colorSteps = await promptStepCount(prompt, "Choose the number of color steps", config.colorSteps);
+    const neutralSteps = await promptStepCount(prompt, "Choose the number of neutral steps", config.neutralSteps);
+    return { ...config, colorSteps, neutralSteps };
+}
+async function exportPalette(prompt, result, writeJson, writeCss) {
+    while (true) {
+        const format = await promptExportFormat(prompt);
+        if (format === "back")
+            return "back";
+        const destination = await promptExportDestination(prompt, format);
+        if (destination.mode === "back")
+            continue;
+        if (format === "json") {
+            if (destination.mode === "save")
+                await writeJson(result, destination.path);
+            else
+                await writeJson(result);
+        }
+        if (format === "css") {
+            if (destination.mode === "save")
+                await writeCss(result, destination.path);
+            else
+                await writeCss(result);
+        }
+        const nextAction = await promptExportCompleteAction(prompt);
+        if (nextAction === "done")
+            return "done";
+        if (nextAction === "back")
+            return "back";
+    }
+}

package/dist/cli/explore.js

@@ -0,0 +1,48 @@
+import { generatePalette } from "../core/generate.js";
+import { generateRandomPaletteConfig } from "../core/random.js";
+import { formatHexOutput } from "./output.js";
+import { promptExplorationAction, } from "./prompt.js";
+import { formatPreview } from "./preview.js";
+const MAX_NEXT_ATTEMPTS = 1024;
+export async function explorePalettes(prompt, useColor, dependencies = {}) {
+    const randomConfig = dependencies.randomConfig ?? generateRandomPaletteConfig;
+    const generate = dependencies.generate ?? generatePalette;
+    const promptAction = dependencies.promptAction ?? promptExplorationAction;
+    const output = dependencies.output ?? console.log;
+    const initialRandom = dependencies.initialSeed === undefined
+        ? randomConfig()
+        : randomConfig({ seed: dependencies.initialSeed });
+    let candidate = createCandidate(initialRandom, generate);
+    while (true) {
+        output(`${formatPreview(candidate.result, useColor)}\n\nSeed: ${candidate.seed}`);
+        const action = await promptAction(prompt);
+        if (action === "accept") {
+            output(`\n${formatHexOutput(candidate.result, useColor)}`);
+            return { action, candidate };
+        }
+        if (action === "edit")
+            return { action, config: candidate.config };
+        if (action === "quit")
+            return { action };
+        candidate = nextCandidate(candidate, randomConfig, generate);
+    }
+}
+function createCandidate(random, generate) {
+    return { ...random, result: generate(random.config) };
+}
+function nextCandidate(current, randomConfig, generate) {
+    const currentSeed = Number.parseInt(current.seed, 16);
+    for (let offset = 1; offset <= MAX_NEXT_ATTEMPTS; offset += 1) {
+        const seed = (currentSeed + offset) >>> 0;
+        const next = createCandidate(randomConfig({ seed }), generate);
+        if (!samePalette(current.result, next.result))
+            return next;
+    }
+    throw new Error("Unable to generate a visually different palette.");
+}
+function samePalette(left, right) {
+    return sameColors(left.colors, right.colors) && sameColors(left.neutrals, right.neutrals);
+}
+function sameColors(left, right) {
+    return left.length === right.length && left.every((color, index) => color === right[index]);
+}

package/dist/cli/generate-command.js

@@ -0,0 +1,45 @@
+import { writeFile } from "node:fs/promises";
+import { DEFAULT_COLOR_STEPS, DEFAULT_NEUTRAL_STEPS } from "../core/constants.js";
+import { generatePalette } from "../core/generate.js";
+import { generateRandomPaletteConfig } from "../core/random.js";
+import { formatCssOutput, formatHexOutput, formatJsonOutput } from "./output.js";
+const DEFAULT_GENERATE_CONFIG = {
+    baseColor: "#2563EB",
+    harmony: "analogous",
+    harmonyTuning: "mechanical",
+    neutralMode: "neutral",
+    colorSteps: DEFAULT_COLOR_STEPS,
+    neutralSteps: DEFAULT_NEUTRAL_STEPS,
+};
+export async function runGenerateCommand(command) {
+    const config = resolveConfig(command);
+    const result = generatePalette(config);
+    const content = `${formatResult(result, command.format)}\n`;
+    if (command.outputPath === undefined) {
+        process.stdout.write(content);
+    }
+    else {
+        await writeFile(command.outputPath, content, "utf8");
+    }
+}
+function resolveConfig(command) {
+    const constraints = {
+        ...(command.baseColor === undefined ? {} : { baseColor: command.baseColor }),
+        ...(command.harmony === undefined ? {} : { harmony: command.harmony }),
+        ...(command.harmonyTuning === undefined ? {} : { harmonyTuning: command.harmonyTuning }),
+        ...(command.neutralMode === undefined ? {} : { neutralMode: command.neutralMode }),
+        ...(command.colorSteps === undefined ? {} : { colorSteps: command.colorSteps }),
+        ...(command.neutralSteps === undefined ? {} : { neutralSteps: command.neutralSteps }),
+    };
+    if (command.seed !== undefined) {
+        return generateRandomPaletteConfig({ seed: command.seed, constraints }).config;
+    }
+    return { ...DEFAULT_GENERATE_CONFIG, ...constraints };
+}
+function formatResult(result, format) {
+    if (format === "json")
+        return formatJsonOutput(result);
+    if (format === "css")
+        return formatCssOutput(result).trimEnd();
+    return formatHexOutput(result, false);
+}

package/dist/cli/index.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { argv, env, stdout } from "node:process";
+import { CliArgumentError, HELP_TEXT, parseCliArgs } from "./args.js";
+import { configurePalette } from "./configure.js";
+import { explorePalettes } from "./explore.js";
+import { runGenerateCommand } from "./generate-command.js";
+import { assertSupportedNodeVersion } from "./node-version.js";
+import { createPromptInterface, PromptCancelledError, promptStartupMode, } from "./prompt.js";
+async function run(args) {
+    assertSupportedNodeVersion();
+    const command = parseCliArgs(args);
+    if (command.name === "help") {
+        console.log(HELP_TEXT);
+        return;
+    }
+    if (command.name === "generate") {
+        await runGenerateCommand(command);
+        return;
+    }
+    const rl = createPromptInterface();
+    const useColor = Boolean(stdout.isTTY && env.NO_COLOR === undefined);
+    console.log("Quick Palette");
+    try {
+        if (command.name === "explore") {
+            const outcome = await explorePalettes(rl, useColor, {
+                ...(command.seed === undefined ? {} : { initialSeed: command.seed }),
+            });
+            if (outcome.action === "edit") {
+                await configurePalette(rl, useColor, outcome.config, { editImmediately: true });
+            }
+            return;
+        }
+        if (command.name === "configure") {
+            await configurePalette(rl, useColor);
+            return;
+        }
+        const startupMode = await promptStartupMode(rl);
+        if (startupMode === "explore") {
+            const outcome = await explorePalettes(rl, useColor);
+            if (outcome.action !== "edit")
+                return;
+            await configurePalette(rl, useColor, outcome.config, { editImmediately: true });
+            return;
+        }
+        await configurePalette(rl, useColor);
+    }
+    finally {
+        rl.close();
+    }
+}
+run(argv.slice(2)).catch((error) => {
+    if (error instanceof PromptCancelledError) {
+        console.error("Cancelled.");
+        process.exitCode = 130;
+        return;
+    }
+    if (error instanceof CliArgumentError) {
+        console.error(`Error: ${error.message}\nRun quick-palette --help for usage.`);
+        process.exitCode = 1;
+        return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Could not complete the command: ${message}`);
+    process.exitCode = 1;
+});

package/dist/cli/node-version.js

@@ -0,0 +1,7 @@
+const MINIMUM_NODE_MAJOR = 22;
+export function assertSupportedNodeVersion(version = process.versions.node) {
+    const major = Number.parseInt(version.split(".")[0] ?? "", 10);
+    if (!Number.isInteger(major) || major < MINIMUM_NODE_MAJOR) {
+        throw new Error(`Node.js ${MINIMUM_NODE_MAJOR} or later is required (current: ${version}).`);
+    }
+}

package/dist/cli/output.js

@@ -0,0 +1,66 @@
+import { writeFile } from "node:fs/promises";
+import { formatColorSwatch } from "./terminal-color.js";
+export function formatHexOutput(result, useColor = false) {
+    const colorLabels = STEP_LABELS[result.config.colorSteps];
+    const neutralLabels = STEP_LABELS[result.config.neutralSteps];
+    const colorGroups = [];
+    for (let start = 0; start < result.colors.length; start += result.config.colorSteps) {
+        const colors = [...result.colors.slice(start, start + result.config.colorSteps)].reverse();
+        colorGroups.push([
+            `Color ${colorGroups.length + 1}`,
+            ...formatScale(colors, colorLabels, useColor),
+        ].join("\n"));
+    }
+    return [
+        "Colors",
+        colorGroups.join("\n\n"),
+        "",
+        "Neutrals",
+        ...formatScale(result.neutrals, neutralLabels, useColor),
+    ].join("\n");
+}
+export function formatJsonOutput(result) {
+    return JSON.stringify(result, null, 2);
+}
+const STEP_LABELS = {
+    3: [100, 500, 900],
+    5: [100, 300, 500, 700, 900],
+    7: [100, 200, 300, 500, 700, 800, 900],
+    9: [100, 200, 300, 400, 500, 600, 700, 800, 900],
+};
+function formatScale(colors, labels, useColor) {
+    return colors.map((hex, index) => (`  ${String(labels[index]).padStart(3)}  ${formatColorSwatch(hex, useColor).trimStart()}`));
+}
+export function formatCssOutput(result) {
+    const colorLabels = STEP_LABELS[result.config.colorSteps];
+    const neutralLabels = STEP_LABELS[result.config.neutralSteps];
+    const colorGroups = [];
+    for (let start = 0; start < result.colors.length; start += result.config.colorSteps) {
+        const colors = [...result.colors.slice(start, start + result.config.colorSteps)].reverse();
+        const groupNumber = colorGroups.length + 1;
+        colorGroups.push(colors.map((hex, index) => (`  --palette-color-${groupNumber}-${colorLabels[index]}: ${hex};`)));
+    }
+    const neutrals = result.neutrals.map((hex, index) => (`  --palette-neutral-${neutralLabels[index]}: ${hex};`));
+    const declarations = [...colorGroups, neutrals]
+        .map((group) => group.join("\n"))
+        .join("\n\n");
+    return `:root {\n${declarations}\n}\n`;
+}
+export async function writeJsonOutput(result, outputPath) {
+    const json = `${formatJsonOutput(result)}\n`;
+    if (!outputPath) {
+        console.log(`\nJSON\n${json}`);
+        return;
+    }
+    await writeFile(outputPath, json, "utf8");
+    console.log(`JSON saved to ${outputPath}`);
+}
+export async function writeCssOutput(result, outputPath) {
+    const css = formatCssOutput(result);
+    if (!outputPath) {
+        console.log(`\nCSS\n${css}`);
+        return;
+    }
+    await writeFile(outputPath, css, "utf8");
+    console.log(`CSS saved to ${outputPath}`);
+}

package/dist/cli/preview.js

@@ -0,0 +1,34 @@
+import { formatHexOutput } from "./output.js";
+const HARMONY_LABELS = {
+    monochrome: "Monochrome",
+    analogous: "Analogous",
+    complementary: "Complementary",
+    triadic: "Triadic",
+};
+const HARMONY_TUNING_LABELS = {
+    mechanical: "Fixed angles",
+    ui: "UI",
+    branding: "Branding",
+    "data-visualization": "Data visualization",
+};
+const NEUTRAL_LABELS = {
+    neutral: "Neutral gray",
+    tinted: "Base-tinted gray",
+};
+export function formatPreview(result, useColor) {
+    const metadata = [
+        `Base color: ${result.config.baseColor}`,
+        `Harmony: ${HARMONY_LABELS[result.config.harmony]}`,
+        ...(result.config.harmony === "monochrome"
+            ? []
+            : [`Harmony style: ${HARMONY_TUNING_LABELS[result.config.harmonyTuning ?? "mechanical"]}`]),
+        `Neutrals: ${NEUTRAL_LABELS[result.config.neutralMode]}`,
+    ];
+    return [
+        "",
+        "Palette preview",
+        ...metadata,
+        "",
+        formatHexOutput(result, useColor),
+    ].join("\n");
+}