@clhaas/palette-kit 0.3.0 → 0.4.0

package/dist/cli.js

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { CliUsageError, COMMANDS, HELP_TEXT, parseArgs } from "./cli/args.js";
-import { generateTokenArtifacts } from "./cli/codegen/tokens.js";
-import { buildConfigTemplate } from "./cli/config.js";
-import { validateConfig } from "./cli/validate.js";
-import { createTheme } from "./core/createTheme.js";
-import { validateTokenRegistry } from "./core/tokenRegistry.js";
-import { exportThemeCss, exportThemeJson } from "./export/exportTheme.js";
-import { minimalUiTokens, modernUiTokens, radixLikeUiTokens } from "./presets/tokens/index.js";
-const readPackageJson = async () => {
-    const url = new URL("../package.json", import.meta.url);
-    const content = await readFile(url, "utf8");
-    return JSON.parse(content);
-};
-const printHelp = () => {
-    console.log(HELP_TEXT);
-};
-const printVersion = async () => {
-    const pkg = await readPackageJson();
-    console.log(pkg.version);
-};
-const ensureDir = async (dir) => {
-    await mkdir(dir, { recursive: true });
-};
-const exists = async (filePath) => {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const loadConfig = async (configPath) => {
-    const resolved = resolve(configPath);
-    try {
-        const module = await import(pathToFileURL(resolved).href);
-        const config = (module.default ?? module);
-        return config;
-    }
-    catch (error) {
-        const suffix = resolved.endsWith(".ts")
-            ? "\nTip: Use a .mjs config or run Node with a TS loader (e.g. tsx)."
-            : "";
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Unable to load config at ${resolved}. ${message}${suffix}`);
-    }
-};
-const tokenPresetMap = {
-    "minimal-ui": minimalUiTokens,
-    "radixLike-ui": radixLikeUiTokens,
-    "modern-ui": modernUiTokens,
-};
-const toThemeTokens = (registry) => Object.fromEntries(Object.entries(registry.tokens).map(([name, token]) => [name, token.query]));
-const writeTokensCodegen = async (outDir, registry) => {
-    const generated = generateTokenArtifacts(registry);
-    await writeFile(join(outDir, "tokens.ts"), generated.tokensTs, "utf8");
-    await writeFile(join(outDir, "tokens.d.ts"), generated.tokensDts, "utf8");
-    return generated.tokenNames;
-};
-const writeReport = async (outDir, config, tokenCount, outputFiles) => {
-    const lines = [
-        "# Palette Kit Report",
-        "",
-        `- preset: ${config.tokens.preset}`,
-        `- tokens: ${tokenCount}`,
-        `- output: preferSpace=${config.output?.preferSpace ?? "oklch"}`,
-        `- includeSpaces: ${(config.output?.includeSpaces ?? []).join(", ") || "(none)"}`,
-        `- files: ${outputFiles.join(", ")}`,
-    ];
-    await writeFile(join(outDir, "report.md"), `${lines.join("\n")}\n`, "utf8");
-};
-const runInit = async (flags) => {
-    const targetPath = typeof flags.path === "string" ? flags.path : ".";
-    const force = Boolean(flags.force);
-    const outDir = resolve(targetPath);
-    await ensureDir(outDir);
-    const filePath = join(outDir, "palette.config.ts");
-    if (!force && (await exists(filePath))) {
-        throw new Error(`Config already exists at ${filePath}. Use --force to overwrite`);
-    }
-    const pkg = await readPackageJson();
-    await writeFile(filePath, buildConfigTemplate(pkg.name), "utf8");
-    console.log(`Created ${filePath}`);
-};
-const runBuild = async (flags) => {
-    const configPath = typeof flags.config === "string" ? flags.config : "palette.config.ts";
-    const outDir = resolve(typeof flags.outDir === "string" ? flags.outDir : "dist/palette");
-    const report = Boolean(flags.report);
-    const config = await loadConfig(configPath);
-    validateConfig(config);
-    const registry = tokenPresetMap[config.tokens.preset];
-    validateTokenRegistry(registry);
-    const theme = createTheme(config.theme);
-    const tokens = toThemeTokens(registry);
-    const css = exportThemeCss(theme, tokens, config.output).css;
-    const json = exportThemeJson(theme, tokens, config.output);
-    await ensureDir(outDir);
-    const tokenNames = await writeTokensCodegen(outDir, registry);
-    await writeFile(join(outDir, "tokens.css"), css, "utf8");
-    await writeFile(join(outDir, "tokens.json"), `${JSON.stringify(json, null, 2)}\n`, "utf8");
-    if (report) {
-        await writeReport(outDir, config, tokenNames.length, [
-            "tokens.css",
-            "tokens.json",
-            "tokens.ts",
-            "tokens.d.ts",
-        ]);
-    }
-    console.log(`Wrote ${basename(outDir)}/tokens.css, tokens.json, tokens.ts, tokens.d.ts`);
-};
-const main = async () => {
-    try {
-        const parsed = parseArgs(process.argv.slice(2));
-        if (parsed.version) {
-            await printVersion();
-            return;
-        }
-        if (parsed.help || !parsed.command) {
-            printHelp();
-            return;
-        }
-        if (!COMMANDS.includes(parsed.command)) {
-            throw new CliUsageError(`Unknown command: ${parsed.command}`);
-        }
-        if (parsed.command === "init") {
-            await runInit(parsed.flags);
-            return;
-        }
-        if (parsed.command === "build") {
-            await runBuild(parsed.flags);
-            return;
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(message);
-        if (error instanceof CliUsageError) {
-            console.error("");
-            printHelp();
-        }
-        process.exitCode = 1;
-    }
-};
-void main();

package/dist/contrast/apca.d.ts

@@ -1,2 +0,0 @@
-import type { SrgbColor } from "./types.js";
-export declare function computeApcaLc(fg: SrgbColor, bg: SrgbColor): number;

package/dist/contrast/apca.js

@@ -1,15 +0,0 @@
-import { APCAcontrast, sRGBtoY } from "apca-w3";
-const clamp01 = (value) => Math.min(1, Math.max(0, value));
-const toApcaInput = (color) => [
-    clamp01(color.r) * 255,
-    clamp01(color.g) * 255,
-    clamp01(color.b) * 255,
-];
-export function computeApcaLc(fg, bg) {
-    const fgY = sRGBtoY(toApcaInput(fg));
-    const bgY = sRGBtoY(toApcaInput(bg));
-    const raw = APCAcontrast(fgY, bgY);
-    const value = typeof raw === "number" ? raw : Number(raw);
-    // Fail-soft to avoid propagating NaN into solver scoring.
-    return Number.isFinite(value) ? value : 0;
-}

package/dist/contrast/apca.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/contrast/apca.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { computeApcaLc } from "./apca.js";
-describe("computeApcaLc", () => {
-    it("reports high magnitude for black on white", () => {
-        const lc = computeApcaLc({ r: 0, g: 0, b: 0 }, { r: 1, g: 1, b: 1 });
-        expect(Math.abs(lc)).toBeGreaterThan(60);
-    });
-    it("reports high magnitude for white on black", () => {
-        const lc = computeApcaLc({ r: 1, g: 1, b: 1 }, { r: 0, g: 0, b: 0 });
-        expect(Math.abs(lc)).toBeGreaterThan(60);
-    });
-    it("does not return NaN", () => {
-        const lc = computeApcaLc({ r: 0.2, g: 0.4, b: 0.6 }, { r: 0.1, g: 0.1, b: 0.1 });
-        expect(Number.isNaN(lc)).toBe(false);
-    });
-});

package/dist/contrast/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./apca.js";
-export * from "./solver.js";
-export * from "./types.js";
-export * from "./wcag2.js";

package/dist/contrast/index.js

@@ -1,4 +0,0 @@
-export * from "./apca.js";
-export * from "./solver.js";
-export * from "./types.js";
-export * from "./wcag2.js";

package/dist/contrast/scoring.d.ts

@@ -1,4 +0,0 @@
-import type { ContrastRequirement } from "../types/index.js";
-import type { ContrastCheckResult } from "./types.js";
-export declare const scoreApca: (value: number, target: number, min: number, max: number, hasMax: boolean) => number;
-export declare const scoreContrast: (result: ContrastCheckResult, req: ContrastRequirement) => number;

package/dist/contrast/scoring.js

@@ -1,31 +0,0 @@
-export const scoreApca = (value, target, min, max, hasMax) => {
-    if (Number.isNaN(value)) {
-        return Number.NEGATIVE_INFINITY;
-    }
-    if (hasMax) {
-        if (value >= min && value <= max) {
-            return 1000 - Math.abs(value - target);
-        }
-        if (value < min) {
-            return -(min - value);
-        }
-        return -(value - max);
-    }
-    if (value < min) {
-        const distance = min - value;
-        return -distance * 10 - Math.abs(value - target);
-    }
-    return -Math.abs(value - target);
-};
-export const scoreContrast = (result, req) => {
-    if (!Number.isFinite(result.value)) {
-        return Number.NEGATIVE_INFINITY;
-    }
-    if (req.model === "apca") {
-        const min = req.minLc ?? req.targetLc;
-        const hasMax = req.maxLc !== undefined;
-        const max = req.maxLc ?? Number.POSITIVE_INFINITY;
-        return scoreApca(result.value, req.targetLc, min, max, hasMax);
-    }
-    return result.value;
-};

package/dist/contrast/scoring.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/contrast/scoring.test.js

@@ -1,148 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { scoreApca, scoreContrast } from "./scoring.js";
-describe("scoreApca", () => {
-    it("prefers values closer to target within range", () => {
-        const target = 60;
-        const min = 50;
-        const max = 80;
-        const hasMax = true;
-        expect(scoreApca(60, target, min, max, hasMax)).toBeGreaterThan(scoreApca(80, target, min, max, hasMax));
-    });
-    it("penalizes values outside the range", () => {
-        const target = 60;
-        const min = 50;
-        const max = 80;
-        const hasMax = true;
-        expect(scoreApca(40, target, min, max, hasMax)).toBeLessThan(0);
-        expect(scoreApca(90, target, min, max, hasMax)).toBeLessThan(0);
-    });
-    it("penalizes below min and prefers target when no max", () => {
-        const target = 60;
-        const min = 50;
-        const max = Number.POSITIVE_INFINITY;
-        const hasMax = false;
-        expect(scoreApca(40, target, min, max, hasMax)).toBeLessThan(scoreApca(55, target, min, max, hasMax));
-        expect(scoreApca(60, target, min, max, hasMax)).toBeGreaterThan(scoreApca(70, target, min, max, hasMax));
-    });
-    it("returns NEGATIVE_INFINITY for NaN values", () => {
-        const target = 60;
-        const min = 50;
-        const max = 80;
-        const hasMax = true;
-        expect(scoreApca(Number.NaN, target, min, max, hasMax)).toBe(Number.NEGATIVE_INFINITY);
-    });
-});
-describe("scoreContrast", () => {
-    describe("with APCA contrast model", () => {
-        it("delegates to scoreApca with correct parameters when maxLc is defined", () => {
-            const result = {
-                model: "apca",
-                target: 60,
-                value: 65,
-                pass: true,
-            };
-            const req = {
-                model: "apca",
-                targetLc: 60,
-                minLc: 50,
-                maxLc: 80,
-            };
-            const score = scoreContrast(result, req);
-            const expectedScore = scoreApca(65, 60, 50, 80, true);
-            expect(score).toBe(expectedScore);
-        });
-        it("delegates to scoreApca without max when maxLc is undefined", () => {
-            const result = {
-                model: "apca",
-                target: 60,
-                value: 65,
-                pass: true,
-            };
-            const req = {
-                model: "apca",
-                targetLc: 60,
-                minLc: 50,
-            };
-            const score = scoreContrast(result, req);
-            const expectedScore = scoreApca(65, 60, 50, Number.POSITIVE_INFINITY, false);
-            expect(score).toBe(expectedScore);
-        });
-        it("uses targetLc as min when minLc is undefined", () => {
-            const result = {
-                model: "apca",
-                target: 60,
-                value: 65,
-                pass: true,
-            };
-            const req = {
-                model: "apca",
-                targetLc: 60,
-            };
-            const score = scoreContrast(result, req);
-            const expectedScore = scoreApca(65, 60, 60, Number.POSITIVE_INFINITY, false);
-            expect(score).toBe(expectedScore);
-        });
-    });
-    describe("with WCAG2 contrast model", () => {
-        it("returns the raw contrast value", () => {
-            const result = {
-                model: "wcag2",
-                target: 4.5,
-                value: 7.2,
-                pass: true,
-            };
-            const req = {
-                model: "wcag2",
-                minRatio: 4.5,
-            };
-            const score = scoreContrast(result, req);
-            expect(score).toBe(7.2);
-        });
-    });
-    describe("with NaN or non-finite values", () => {
-        it("returns NEGATIVE_INFINITY for NaN", () => {
-            const result = {
-                model: "apca",
-                target: 60,
-                value: Number.NaN,
-                pass: false,
-            };
-            const req = {
-                model: "apca",
-                targetLc: 60,
-                minLc: 50,
-            };
-            const score = scoreContrast(result, req);
-            expect(score).toBe(Number.NEGATIVE_INFINITY);
-        });
-        it("returns NEGATIVE_INFINITY for positive infinity", () => {
-            const result = {
-                model: "apca",
-                target: 60,
-                value: Number.POSITIVE_INFINITY,
-                pass: false,
-            };
-            const req = {
-                model: "apca",
-                targetLc: 60,
-                minLc: 50,
-            };
-            const score = scoreContrast(result, req);
-            expect(score).toBe(Number.NEGATIVE_INFINITY);
-        });
-        it("returns NEGATIVE_INFINITY for negative infinity", () => {
-            const result = {
-                model: "wcag2",
-                target: 4.5,
-                value: Number.NEGATIVE_INFINITY,
-                pass: false,
-            };
-            const req = {
-                model: "wcag2",
-                minRatio: 4.5,
-            };
-            const score = scoreContrast(result, req);
-            expect(score).toBe(Number.NEGATIVE_INFINITY);
-        });
-    });
-});

package/dist/contrast/solver.d.ts

@@ -1,13 +0,0 @@
-import type { OkLchColor } from "../engine/generateScale.js";
-import type { CurvePresetName } from "../presets/index.js";
-import type { ContrastRequirement, SurfaceIntent } from "../types/index.js";
-import type { ContrastCheckResult, SolveOptions } from "./types.js";
-export declare function solveContrast(fg: OkLchColor, bg: OkLchColor | undefined, req: ContrastRequirement, ctx: {
-    preset?: CurvePresetName;
-    surface: SurfaceIntent;
-    context: "light" | "dark";
-}, opts?: SolveOptions): {
-    color: OkLchColor;
-    result: ContrastCheckResult;
-    iterations: number;
-};

package/dist/contrast/solver.js

@@ -1,170 +0,0 @@
-import { converter } from "culori";
-import { getSurfaceRange } from "../operators/utils.js";
-import { computeApcaLc } from "./apca.js";
-import { scoreContrast } from "./scoring.js";
-import { contrastRatio } from "./wcag2.js";
-const toSrgb = converter("rgb");
-const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-const clampOkLch = (color, cMax) => ({
-    l: clamp(color.l, 0, 100),
-    c: clamp(color.c, 0, cMax),
-    h: color.h,
-    alpha: color.alpha,
-});
-const clampOkLchLoose = (color) => ({
-    l: clamp(color.l, 0, 100),
-    c: Math.max(0, color.c),
-    h: color.h,
-    alpha: color.alpha,
-});
-const toSrgbColor = (color) => {
-    const rgb = toSrgb({ mode: "oklch", l: clamp(color.l, 0, 100) / 100, c: color.c, h: color.h });
-    if (!rgb) {
-        return null;
-    }
-    const r = typeof rgb.r === "number" && Number.isFinite(rgb.r) ? clamp(rgb.r, 0, 1) : 0;
-    const g = typeof rgb.g === "number" && Number.isFinite(rgb.g) ? clamp(rgb.g, 0, 1) : 0;
-    const b = typeof rgb.b === "number" && Number.isFinite(rgb.b) ? clamp(rgb.b, 0, 1) : 0;
-    return { r, g, b };
-};
-const getTarget = (req) => {
-    if (req.model === "apca") {
-        return req.targetLc;
-    }
-    if (req.model === "wcag2") {
-        return req.minRatio;
-    }
-    return 0;
-};
-const checkContrast = (fg, bg, req, epsilon) => {
-    if (req.model === "none") {
-        return { model: "none", target: 0, value: 0, pass: true };
-    }
-    const fgSrgb = toSrgbColor(fg);
-    const bgSrgb = toSrgbColor(bg);
-    const target = getTarget(req);
-    if (!fgSrgb || !bgSrgb) {
-        return { model: req.model, target, value: Number.NaN, pass: false };
-    }
-    if (req.model === "apca") {
-        const value = Math.abs(computeApcaLc(fgSrgb, bgSrgb));
-        const minTarget = req.minLc ?? req.targetLc;
-        const maxTarget = req.maxLc ?? Number.POSITIVE_INFINITY;
-        const pass = Number.isFinite(value) && value >= minTarget - epsilon && value <= maxTarget + epsilon;
-        return { model: "apca", target, value, pass };
-    }
-    const value = contrastRatio(fgSrgb, bgSrgb);
-    const pass = Number.isFinite(value) && value + epsilon >= target;
-    return { model: "wcag2", target, value, pass };
-};
-const pickBetter = (current, candidate, req) => {
-    const currentScore = scoreContrast(current.result, req);
-    const candidateScore = scoreContrast(candidate.result, req);
-    return candidateScore > currentScore ? candidate : current;
-};
-export function solveContrast(fg, bg, req, ctx, opts) {
-    const options = {
-        strict: false,
-        maxIterations: 24,
-        epsilon: 0.01,
-        ...opts,
-    };
-    if (req.model === "none") {
-        return {
-            color: fg,
-            result: { model: "none", target: 0, value: 0, pass: true },
-            iterations: 0,
-        };
-    }
-    if (!bg) {
-        if (options.strict) {
-            throw new Error("Contrast solver requires background");
-        }
-        return {
-            color: fg,
-            result: { model: req.model, target: getTarget(req), value: Number.NaN, pass: false },
-            iterations: 0,
-        };
-    }
-    const range = getSurfaceRange(ctx.preset, ctx.surface, ctx.context);
-    const clamped = clampOkLch(fg, range.cMax);
-    const background = clampOkLchLoose(bg);
-    let iterations = 0;
-    const evaluate = (color) => {
-        const result = checkContrast(color, background, req, options.epsilon);
-        iterations += 1;
-        return result;
-    };
-    let best = { color: clamped, result: evaluate(clamped) };
-    if (best.result.pass) {
-        return { ...best, iterations };
-    }
-    const lMin = 0;
-    const lMax = 100;
-    const sampleT = 0.25;
-    const sampleDown = clamp(clamped.l + (lMin - clamped.l) * sampleT, lMin, lMax);
-    const sampleUp = clamp(clamped.l + (lMax - clamped.l) * sampleT, lMin, lMax);
-    let preferredBound = lMin;
-    if (iterations < options.maxIterations) {
-        const downCandidate = {
-            color: { ...clamped, l: sampleDown },
-            result: evaluate({ ...clamped, l: sampleDown }),
-        };
-        best = pickBetter(best, downCandidate, req);
-        if (best.result.pass) {
-            return { ...best, iterations };
-        }
-        if (iterations < options.maxIterations) {
-            const upCandidate = {
-                color: { ...clamped, l: sampleUp },
-                result: evaluate({ ...clamped, l: sampleUp }),
-            };
-            best = pickBetter(best, upCandidate, req);
-            if (best.result.pass) {
-                return { ...best, iterations };
-            }
-            preferredBound =
-                scoreContrast(upCandidate.result, req) > scoreContrast(downCandidate.result, req)
-                    ? lMax
-                    : lMin;
-        }
-    }
-    const remainingAfterSamples = Math.max(0, options.maxIterations - iterations);
-    const lSteps = Math.max(4, remainingAfterSamples);
-    for (let step = 1; step <= lSteps && iterations < options.maxIterations; step += 1) {
-        const t = step / lSteps;
-        const l = clamp(clamped.l + (preferredBound - clamped.l) * t, lMin, lMax);
-        const candidateColor = { ...clamped, l };
-        const result = evaluate(candidateColor);
-        const candidate = { color: candidateColor, result };
-        best = pickBetter(best, candidate, req);
-        if (result.pass) {
-            return { color: candidateColor, result, iterations };
-        }
-    }
-    let current = { ...best.color };
-    while (iterations < options.maxIterations && current.c > 0) {
-        const nextC = clamp(current.c * 0.9, 0, range.cMax);
-        current = { ...current, c: nextC };
-        const result = evaluate(current);
-        best = pickBetter(best, { color: current, result }, req);
-        if (result.pass) {
-            return { color: current, result, iterations };
-        }
-        const sweepSteps = Math.min(3, options.maxIterations - iterations);
-        for (let step = 1; step <= sweepSteps && iterations < options.maxIterations; step += 1) {
-            const t = step / sweepSteps;
-            const l = clamp(current.l + (preferredBound - current.l) * t, lMin, lMax);
-            const candidateColor = { ...current, l };
-            const candidateResult = evaluate(candidateColor);
-            best = pickBetter(best, { color: candidateColor, result: candidateResult }, req);
-            if (candidateResult.pass) {
-                return { color: candidateColor, result: candidateResult, iterations };
-            }
-        }
-    }
-    if (options.strict) {
-        throw new Error(`Contrast solver failed (${best.result.model}) target=${best.result.target} value=${best.result.value} iterations=${iterations}`);
-    }
-    return { color: best.color, result: best.result, iterations };
-}

package/dist/contrast/solver.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/contrast/solver.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseColor } from "../utils/parseColor.js";
-import { solveContrast } from "./solver.js";
-const toOkLch = (hex) => {
-    const parsed = parseColor(hex);
-    return {
-        l: parsed.okLch.channels[0] * 100,
-        c: parsed.okLch.channels[1],
-        h: parsed.okLch.channels[2],
-        alpha: parsed.okLch.alpha,
-    };
-};
-describe("solveContrast", () => {
-    it("raises contrast on light backgrounds", () => {
-        const fg = toOkLch("#777777");
-        const bg = toOkLch("#ffffff");
-        const result = solveContrast(fg, bg, { model: "wcag2", minRatio: 4.5 }, { surface: "surface", context: "light" });
-        expect(result.result.pass).toBe(true);
-        expect(result.result.value).toBeGreaterThanOrEqual(4.5);
-        expect(result.color.l).toBeGreaterThanOrEqual(0);
-        expect(result.color.l).toBeLessThanOrEqual(100);
-        expect(result.color.c).toBeGreaterThanOrEqual(0);
-    });
-    it("returns original color when contrast model is none", () => {
-        const fg = toOkLch("#777777");
-        const bg = toOkLch("#ffffff");
-        const result = solveContrast(fg, bg, { model: "none" }, { surface: "surface", context: "light" });
-        expect(result.result.pass).toBe(true);
-        expect(result.iterations).toBe(0);
-        expect(result.color).toEqual(fg);
-    });
-    it("skips when background is missing and strict is false", () => {
-        const fg = toOkLch("#777777");
-        const result = solveContrast(fg, undefined, { model: "wcag2", minRatio: 4.5 }, { surface: "surface", context: "light" }, { strict: false });
-        expect(result.result.pass).toBe(false);
-        expect(Number.isNaN(result.result.value)).toBe(true);
-    });
-    it("throws when background is missing and strict is true", () => {
-        const fg = toOkLch("#777777");
-        expect(() => solveContrast(fg, undefined, { model: "wcag2", minRatio: 4.5 }, { surface: "surface", context: "light" }, { strict: true })).toThrowError(/requires background/i);
-    });
-    it("raises contrast on dark backgrounds", () => {
-        const fg = toOkLch("#777777");
-        const bg = toOkLch("#111111");
-        const result = solveContrast(fg, bg, { model: "wcag2", minRatio: 4.5 }, { surface: "surface", context: "dark" });
-        expect(result.result.pass).toBe(true);
-        expect(result.result.value).toBeGreaterThanOrEqual(4.5);
-    });
-    it("keeps hue stable", () => {
-        const fg = toOkLch("#3366ff");
-        const bg = toOkLch("#ffffff");
-        const result = solveContrast(fg, bg, { model: "wcag2", minRatio: 4.5 }, { surface: "surface", context: "light" });
-        expect(result.color.h).toBeCloseTo(fg.h, 6);
-    });
-    it("throws in strict mode when target is unattainable", () => {
-        const fg = toOkLch("#ffffff");
-        const bg = toOkLch("#ffffff");
-        expect(() => solveContrast(fg, bg, { model: "wcag2", minRatio: 30 }, { surface: "surface", context: "light" }, { strict: true })).toThrowError(/contrast solver failed/i);
-    });
-    it("prefers APCA values closer to target within the allowed range", () => {
-        const fg = toOkLch("#777777");
-        const bg = toOkLch("#ffffff");
-        const minLc = 50;
-        const maxLc = 80;
-        const targetLc = 60;
-        const result = solveContrast(fg, bg, { model: "apca", targetLc, minLc, maxLc }, { surface: "surface", context: "light" });
-        const value = result.result.value;
-        const targetDistance = Math.abs(value - targetLc);
-        const maxDistance = Math.abs(maxLc - targetLc);
-        expect(result.result.pass).toBe(true);
-        expect(value).toBeGreaterThanOrEqual(minLc);
-        expect(value).toBeLessThanOrEqual(maxLc);
-        expect(targetDistance).toBeLessThanOrEqual(maxDistance);
-    });
-});

package/dist/contrast/types.d.ts

@@ -1,17 +0,0 @@
-export type ContrastModel = "apca" | "wcag2" | "none";
-export type ContrastCheckResult = {
-    model: ContrastModel;
-    target: number;
-    value: number;
-    pass: boolean;
-};
-export type SolveOptions = {
-    strict?: boolean;
-    maxIterations?: number;
-    epsilon?: number;
-};
-export type SrgbColor = {
-    r: number;
-    g: number;
-    b: number;
-};

package/dist/contrast/types.js

@@ -1 +0,0 @@
-export {};