@clhaas/palette-kit 0.3.0 → 0.4.0

package/dist/engine/normalize.js

@@ -1,403 +0,0 @@
-const usages = ["bg", "border", "text", "icon", "ring", "shadow", "stroke", "fill"];
-const onSolidUsages = ["text", "icon"];
-const contexts = ["light", "dark", "highContrast", "dimmed"];
-const surfaces = [
-    "app",
-    "surface",
-    "subtle",
-    "solid",
-    "overlay",
-    "data",
-    "transparent",
-];
-export const COLOR_STATES = [
-    "default",
-    "hover",
-    "active",
-    "selected",
-    "focus",
-    "disabled",
-];
-const emphases = ["muted", "subtle", "default", "strong", "inverted"];
-const semanticVariants = [
-    "neutral",
-    "accent",
-    "success",
-    "warning",
-    "danger",
-    "info",
-    "highlight",
-    "premium",
-];
-const colorSpaces = ["srgb", "p3", "oklch"];
-const gamutMappings = [
-    "clip",
-    "compressChroma",
-    "preferP3ThenCompress",
-];
-const srgbFormats = ["hex", "rgb", "rgba"];
-const formatString = (value) => (value ? value.trim() : undefined);
-const assertOneOf = (value, options, label) => {
-    if (!options.includes(value)) {
-        throw new Error(`Invalid ${label}: "${value}"`);
-    }
-    return value;
-};
-const normalizeRole = (role) => {
-    if (role === undefined) {
-        throw new Error("Color role is required");
-    }
-    const trimmed = role.trim();
-    if (!trimmed) {
-        throw new Error("Color role is required");
-    }
-    return trimmed;
-};
-const normalizeBgRole = (role) => {
-    if (role === undefined) {
-        throw new Error("Background role (bgRole) is required");
-    }
-    const trimmed = role.trim();
-    if (!trimmed) {
-        throw new Error("Background role (bgRole) is required");
-    }
-    return trimmed;
-};
-const hexColorPattern = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
-const inferUsageFromRole = (role) => {
-    const normalizedRole = role.trim().toLowerCase();
-    if (normalizedRole.startsWith("text.")) {
-        return "text";
-    }
-    if (normalizedRole.startsWith("icon.")) {
-        return "icon";
-    }
-    if (normalizedRole.startsWith("border.")) {
-        return "border";
-    }
-    if (normalizedRole.startsWith("bg.") ||
-        normalizedRole.startsWith("surface.") ||
-        normalizedRole.startsWith("overlay.")) {
-        return "bg";
-    }
-    if (normalizedRole.startsWith("focus.") || normalizedRole.startsWith("ring.")) {
-        return "ring";
-    }
-    if (normalizedRole.startsWith("chart.")) {
-        const tokens = normalizedRole.split(".");
-        if (tokens.includes("stroke")) {
-            return "stroke";
-        }
-        if (tokens.includes("fill")) {
-            return "fill";
-        }
-        if (tokens.includes("grid")) {
-            return "border";
-        }
-        if (tokens.includes("label") || tokens.includes("text")) {
-            return "text";
-        }
-    }
-    return undefined;
-};
-/**
- * Infer surface intent from role naming patterns.
- *
- * Recognizes:
- * - Direct surface token prefixes: `"app.*"`, `"surface.*"`, `"solid.*"`, etc.
- * - Background patterns: `"bg.app"`, `"bg.surface"`, `"bg.solid"`, etc.
- *
- * @example
- * inferSurfaceFromRole("bg.app") // "app"
- * @example
- * inferSurfaceFromRole("app.bg") // "app"
- */
-const inferSurfaceFromRole = (role) => {
-    const normalizedRole = role.trim().toLowerCase();
-    const tokens = normalizedRole.split(".");
-    const [first, second] = tokens;
-    if (first && surfaces.includes(first)) {
-        return first;
-    }
-    if (first === "bg" && second && surfaces.includes(second)) {
-        return second;
-    }
-    return undefined;
-};
-/**
- * Infer semantic variant from role token.
- *
- * Recognizes:
- * - Semantic variants: `"neutral"`, `"accent"`, `"success"`, `"warning"`, etc.
- * - Custom categories: `"category:*"`
- * - Chart variants: `"chart:*"`
- *
- * @example
- * inferVariantFromRole("success.bg") // "success"
- * @example
- * inferVariantFromRole("category:sales.fill") // "category:sales"
- */
-const inferVariantFromRole = (role) => {
-    const token = role.trim().split(".")[0];
-    const normalized = token?.toLowerCase();
-    if (!normalized) {
-        return undefined;
-    }
-    if (semanticVariants.includes(normalized)) {
-        return normalized;
-    }
-    if (/^(category|chart):.+/.test(normalized)) {
-        return normalized;
-    }
-    return undefined;
-};
-const normalizeVariant = (variant) => {
-    if (!variant) {
-        return undefined;
-    }
-    const trimmed = variant.trim();
-    if (semanticVariants.includes(trimmed)) {
-        return trimmed;
-    }
-    if (/^(category|chart):.+/.test(trimmed)) {
-        return trimmed;
-    }
-    throw new Error(`Invalid variant: "${variant}"`);
-};
-const warn = (message) => {
-    console.warn(message);
-};
-/**
- * Cache used to deduplicate inference warnings.
- *
- * Notes:
- * - This is intentionally module-scoped so repeated calls don't spam logs.
- * - To avoid unbounded growth in long-running processes, this cache is capped
- *   and clears itself when the cap is reached.
- */
-const inferenceWarnings = new Set();
-const MAX_INFERENCE_WARNINGS = 1000;
-const warnInferenceOnce = (key, message) => {
-    if (inferenceWarnings.has(key))
-        return;
-    if (inferenceWarnings.size >= MAX_INFERENCE_WARNINGS) {
-        inferenceWarnings.clear();
-    }
-    inferenceWarnings.add(key);
-    console.warn(message);
-};
-const missingUsageMessage = (role) => `Usage is required for role: "${role}". Provide usage explicitly (e.g. { usage: "text" }) or use a role prefix like "text.", "icon.", "bg.", "border.", "ring."`;
-const missingSurfaceMessage = (role) => `Surface is required for role: "${role}". Provide surface explicitly (e.g. { surface: "surface" }) or use a role pattern like "bg.app", "bg.surface", "app.*"`;
-const normalizeBackgroundHint = (hint, strict) => {
-    if (!hint) {
-        return undefined;
-    }
-    if (hint.kind === "auto") {
-        return hint;
-    }
-    if (hint.kind === "role") {
-        const trimmedRole = normalizeRole(hint.role);
-        return { kind: "role", role: trimmedRole };
-    }
-    if (hint.kind === "color") {
-        const value = hint.value.trim();
-        if (!value) {
-            throw new Error("Background hint color value is required");
-        }
-        if (!hexColorPattern.test(value)) {
-            if (strict) {
-                throw new Error(`Invalid background hint color value: "${hint.value}"`);
-            }
-            warn(`Unvalidated background hint color value: "${hint.value}"`);
-        }
-        return { kind: "color", value };
-    }
-    throw new Error(`Invalid background hint kind: "${hint.kind}"`);
-};
-const normalizeContrast = (contrast) => {
-    if (!contrast) {
-        return undefined;
-    }
-    if (contrast.model === "apca") {
-        if (!Number.isFinite(contrast.targetLc)) {
-            throw new Error("APCA targetLc must be a number");
-        }
-        if (contrast.minLc !== undefined && !Number.isFinite(contrast.minLc)) {
-            throw new Error("APCA minLc must be a number");
-        }
-        if (contrast.maxLc !== undefined && !Number.isFinite(contrast.maxLc)) {
-            throw new Error("APCA maxLc must be a number");
-        }
-        // Validate logical relationships between APCA contrast bounds
-        if (contrast.minLc !== undefined && contrast.maxLc !== undefined) {
-            if (contrast.minLc > contrast.maxLc) {
-                throw new Error("APCA minLc cannot be greater than maxLc");
-            }
-        }
-        if (contrast.minLc !== undefined && contrast.minLc > contrast.targetLc) {
-            throw new Error("APCA minLc cannot be greater than targetLc");
-        }
-        if (contrast.maxLc !== undefined && contrast.targetLc > contrast.maxLc) {
-            throw new Error("APCA targetLc cannot be greater than maxLc");
-        }
-        return contrast;
-    }
-    if (contrast.model === "wcag2") {
-        const minRatio = "minRatio" in contrast ? contrast.minRatio : contrast.ratio;
-        if (minRatio === undefined) {
-            throw new Error("WCAG2 contrast requires either 'minRatio' or legacy 'ratio' property");
-        }
-        if (!Number.isFinite(minRatio)) {
-            throw new Error("WCAG2 minRatio must be a number");
-        }
-        return { model: "wcag2", minRatio };
-    }
-    if (contrast.model === "none") {
-        return contrast;
-    }
-    throw new Error(`Invalid contrast model: "${contrast.model}"`);
-};
-const validateIncludeSpaces = (includeSpaces) => {
-    const value = includeSpaces ?? [];
-    value.forEach((space) => {
-        assertOneOf(space, colorSpaces, "output includeSpaces");
-    });
-    return value;
-};
-const normalizeAlpha = (alpha) => {
-    if (!alpha) {
-        return undefined;
-    }
-    if (alpha.mode === "none") {
-        return alpha;
-    }
-    if (alpha.mode === "fixed") {
-        if (!Number.isFinite(alpha.alpha)) {
-            throw new Error("Fixed alpha must be a number");
-        }
-        return alpha;
-    }
-    if (alpha.mode === "solveOnBackground") {
-        return alpha;
-    }
-    throw new Error(`Invalid alpha strategy mode: "${alpha.mode}"`);
-};
-const normalizeOutput = (output) => {
-    const preferSpaceValue = formatString(output?.preferSpace);
-    const gamutMappingValue = formatString(output?.gamutMapping);
-    const srgbFormatValue = formatString(output?.srgbFormat);
-    const includeSpaces = validateIncludeSpaces(output?.includeSpaces);
-    const preferSpace = preferSpaceValue
-        ? assertOneOf(preferSpaceValue, colorSpaces, "output preferSpace")
-        : "oklch";
-    const gamutMapping = gamutMappingValue
-        ? assertOneOf(gamutMappingValue, gamutMappings, "output gamutMapping")
-        : "preferP3ThenCompress";
-    const srgbFormat = srgbFormatValue
-        ? assertOneOf(srgbFormatValue, srgbFormats, "output srgbFormat")
-        : "hex";
-    if (output?.strict !== undefined && typeof output.strict !== "boolean") {
-        throw new Error("Output strict must be a boolean");
-    }
-    if (output?.includeMeta !== undefined && typeof output.includeMeta !== "boolean") {
-        throw new Error("Output includeMeta must be a boolean");
-    }
-    return {
-        preferSpace,
-        includeSpaces,
-        gamutMapping,
-        strict: output?.strict ?? false,
-        precision: {
-            l: 1,
-            c: 3,
-            h: 1,
-            ...output?.precision,
-        },
-        includeMeta: output?.includeMeta ?? false,
-        srgbFormat,
-    };
-};
-/**
- * Normalize a user-facing ColorQuery into a fully populated, validated structure.
- *
- * - Applies defaults for missing fields (context, surface, state, emphasis, output).
- * - Infers usage and surface from role naming patterns when not provided.
- * - In strict mode, missing required fields throw actionable errors.
- * - In non-strict mode, safe defaults are applied with explicit warnings.
- * - Validates nested objects (background hints, contrast requirements, alpha strategies).
- * - Trims string inputs and enforces allowed enum values.
- *
- * @example
- * normalizeQuery({ role: "text.primary" });
- * @example
- * normalizeQuery({
- *   role: "bg.canvas",
- *   on: { kind: "color", value: "#fff" },
- *   contrast: { model: "apca", targetLc: 60 },
- *   output: { strict: true },
- * });
- */
-export function normalizeQuery(q) {
-    const role = normalizeRole(formatString(q.role));
-    const contextValue = formatString(q.context) ?? "light";
-    const inferredSurface = inferSurfaceFromRole(role);
-    const surfaceValue = formatString(q.surface) ?? inferredSurface ?? "surface";
-    const stateValue = formatString(q.state) ?? "default";
-    const emphasisValue = formatString(q.emphasis) ?? "default";
-    const output = normalizeOutput(q.output);
-    const usageValue = formatString(q.usage) ?? inferUsageFromRole(role);
-    const variantValue = formatString(q.variant) ?? inferVariantFromRole(role);
-    if (!usageValue) {
-        if (output.strict) {
-            throw new Error(missingUsageMessage(role));
-        }
-        warnInferenceOnce(`usage:${role}`, `Defaulting usage to "bg" for role: "${role}". ${missingUsageMessage(role)}`);
-    }
-    if (!formatString(q.surface) && !inferredSurface) {
-        if (output.strict) {
-            throw new Error(missingSurfaceMessage(role));
-        }
-        warnInferenceOnce(`surface:${role}`, `Defaulting surface to "surface" for role: "${role}". ${missingSurfaceMessage(role)}`);
-    }
-    return {
-        role,
-        usage: assertOneOf(usageValue ?? "bg", usages, "usage"),
-        context: assertOneOf(contextValue, contexts, "context"),
-        surface: assertOneOf(surfaceValue, surfaces, "surface"),
-        state: assertOneOf(stateValue, COLOR_STATES, "state"),
-        emphasis: assertOneOf(emphasisValue, emphases, "emphasis"),
-        variant: normalizeVariant(variantValue),
-        on: normalizeBackgroundHint(q.on, output.strict),
-        contrast: normalizeContrast(q.contrast),
-        alpha: normalizeAlpha(q.alpha),
-        output,
-    };
-}
-/**
- * Normalize a user-facing OnSolidQuery into a fully populated, validated structure.
- *
- * - Applies defaults for missing fields (context, state, emphasis, output).
- * - Validates usage ("text" | "icon") and required background role.
- * - Validates nested objects (contrast requirements, alpha strategies).
- */
-export function normalizeOnSolidQuery(q) {
-    const bgRole = normalizeBgRole(formatString(q.bgRole));
-    const usageValue = formatString(q.usage);
-    const contextValue = formatString(q.context) ?? "light";
-    const stateValue = formatString(q.state) ?? "default";
-    const emphasisValue = formatString(q.emphasis) ?? "default";
-    const output = normalizeOutput(q.output);
-    if (!usageValue) {
-        throw new Error("On-solid usage is required (text or icon)");
-    }
-    return {
-        bgRole,
-        usage: assertOneOf(usageValue, onSolidUsages, "onSolid usage"),
-        context: assertOneOf(contextValue, contexts, "context"),
-        state: assertOneOf(stateValue, COLOR_STATES, "state"),
-        emphasis: assertOneOf(emphasisValue, emphases, "emphasis"),
-        contrast: normalizeContrast(q.contrast),
-        alpha: normalizeAlpha(q.alpha),
-        output,
-    };
-}

package/dist/engine/normalize.test.d.ts

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

package/dist/engine/normalize.test.js

@@ -1,136 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { normalizeQuery } from "./normalize.js";
-describe("normalizeQuery", () => {
-    it("applies defaults", () => {
-        const result = normalizeQuery({ role: "text.primary", surface: "surface" });
-        expect(result.usage).toBe("text");
-        expect(result.context).toBe("light");
-        expect(result.surface).toBe("surface");
-        expect(result.state).toBe("default");
-        expect(result.emphasis).toBe("default");
-    });
-    it("throws when role is missing", () => {
-        expect(() => normalizeQuery({})).toThrowError(/role/i);
-    });
-    it("applies output defaults", () => {
-        const result = normalizeQuery({ role: "text.primary", surface: "surface" });
-        expect(result.output.preferSpace).toBe("oklch");
-        expect(result.output.gamutMapping).toBe("preferP3ThenCompress");
-        expect(result.output.precision).toMatchObject({ l: 1, c: 3, h: 1 });
-        expect(result.output.strict).toBe(false);
-        expect(result.output.includeMeta).toBe(false);
-    });
-    it("infers usage from role prefixes", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        try {
-            expect(normalizeQuery({ role: "icon.primary" }).usage).toBe("icon");
-            expect(normalizeQuery({ role: "border.muted" }).usage).toBe("border");
-            expect(normalizeQuery({ role: "bg.canvas" }).usage).toBe("bg");
-            expect(normalizeQuery({ role: "ring.focus" }).usage).toBe("ring");
-            expect(normalizeQuery({ role: "chart.axis.stroke" }).usage).toBe("stroke");
-            expect(normalizeQuery({ role: "chart.fill.primary" }).usage).toBe("fill");
-            expect(normalizeQuery({ role: "chart.grid.muted" }).usage).toBe("border");
-            expect(normalizeQuery({ role: "chart.label" }).usage).toBe("text");
-        }
-        finally {
-            warnSpy.mockRestore();
-        }
-    });
-    it("infers surface when obvious", () => {
-        expect(normalizeQuery({ role: "bg.app" }).surface).toBe("app");
-        expect(normalizeQuery({ role: "bg.surface" }).surface).toBe("surface");
-        expect(normalizeQuery({ role: "app.bg", usage: "bg" }).surface).toBe("app");
-    });
-    it("infers variant from role token", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        try {
-            expect(normalizeQuery({ role: "success.bg", usage: "bg", surface: "surface" }).variant).toBe("success");
-            expect(normalizeQuery({ role: "warning.text", usage: "text", surface: "surface" }).variant).toBe("warning");
-            expect(normalizeQuery({ role: "danger.border", usage: "border", surface: "surface" }).variant).toBe("danger");
-            expect(normalizeQuery({ role: "category:sales.fill", usage: "fill", surface: "surface" }).variant).toBe("category:sales");
-            expect(normalizeQuery({
-                role: "chart:revenue.stroke",
-                usage: "stroke",
-                surface: "surface",
-            }).variant).toBe("chart:revenue");
-            expect(normalizeQuery({ role: "text.primary", usage: "text", surface: "surface" }).variant).toBeUndefined();
-        }
-        finally {
-            warnSpy.mockRestore();
-        }
-    });
-    it("requires usage when strict and inference fails", () => {
-        expect(() => normalizeQuery({ role: "brand.primary", output: { strict: true } })).toThrowError(/Provide usage explicitly/i);
-    });
-    it("warns when usage cannot be inferred in non-strict mode", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        expect(normalizeQuery({ role: "brand.primary" }).usage).toBe("bg");
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Defaulting usage to "bg"'));
-        warnSpy.mockRestore();
-    });
-    it("requires surface when strict and inference fails", () => {
-        expect(() => normalizeQuery({ role: "text.primary", output: { strict: true } })).toThrowError(/Provide surface explicitly/i);
-    });
-    it("warns when surface cannot be inferred in non-strict mode", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        expect(normalizeQuery({ role: "text.primary" }).surface).toBe("surface");
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Defaulting surface to "surface"'));
-        warnSpy.mockRestore();
-    });
-    it("validates background hint color values", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        expect(normalizeQuery({ role: "bg.canvas", surface: "surface", on: { kind: "color", value: "#fff" } })
-            .on).toEqual({ kind: "color", value: "#fff" });
-        expect(normalizeQuery({
-            role: "bg.canvas",
-            surface: "surface",
-            on: { kind: "color", value: "oklch(62% 0.18 265)" },
-        }).on).toEqual({ kind: "color", value: "oklch(62% 0.18 265)" });
-        expect(normalizeQuery({
-            role: "bg.canvas",
-            surface: "surface",
-            on: { kind: "color", value: "color(display-p3 1 0.5 0.25)" },
-        }).on).toEqual({ kind: "color", value: "color(display-p3 1 0.5 0.25)" });
-        expect(normalizeQuery({ role: "bg.canvas", surface: "surface", on: { kind: "color", value: "banana" } })
-            .on).toEqual({ kind: "color", value: "banana" });
-        expect(warnSpy).toHaveBeenCalledTimes(3);
-        warnSpy.mockRestore();
-    });
-    it("normalizes nested background hints", () => {
-        expect(normalizeQuery({
-            role: "bg.canvas",
-            surface: "surface",
-            on: { kind: "role", role: " text.primary " },
-        })
-            .on).toEqual({ kind: "role", role: "text.primary" });
-        expect(normalizeQuery({ role: "bg.canvas", surface: "surface", on: { kind: "auto" } }).on).toEqual({
-            kind: "auto",
-        });
-        expect(() => normalizeQuery({ role: "bg.canvas", surface: "surface", on: { kind: "color", value: "   " } })).toThrowError(/color value is required/i);
-        expect(() => normalizeQuery({
-            role: "bg.canvas",
-            surface: "surface",
-            on: { kind: "color", value: "banana" },
-            output: { strict: true },
-        })).toThrowError(/background hint color value/i);
-        expect(() => normalizeQuery({ role: "bg.canvas", surface: "surface", on: { kind: "nope" } })).toThrowError(/background hint kind/i);
-    });
-    it("validates contrast requirements", () => {
-        expect(normalizeQuery({ role: "text.primary", contrast: { model: "apca", targetLc: 75 } })
-            .contrast).toEqual({ model: "apca", targetLc: 75 });
-        expect(normalizeQuery({ role: "text.primary", contrast: { model: "wcag2", minRatio: 4.5 } })
-            .contrast).toEqual({ model: "wcag2", minRatio: 4.5 });
-        expect(normalizeQuery({ role: "text.primary", contrast: { model: "none" } }).contrast).toEqual({ model: "none" });
-        expect(() => normalizeQuery({ role: "text.primary", contrast: { model: "apca" } })).toThrowError(/targetLc/i);
-        expect(() => normalizeQuery({ role: "text.primary", contrast: { model: "wcag2" } })).toThrowError(/minRatio.*ratio/i);
-        expect(() => normalizeQuery({ role: "text.primary", contrast: { model: "wcag2", minRatio: NaN } })).toThrowError(/minRatio must be a number/i);
-        expect(() => normalizeQuery({ role: "text.primary", contrast: { model: "nope" } })).toThrowError(/contrast model/i);
-    });
-    it("validates alpha strategies", () => {
-        expect(normalizeQuery({ role: "bg.canvas", alpha: { mode: "none" } }).alpha).toEqual({ mode: "none" });
-        expect(normalizeQuery({ role: "bg.canvas", alpha: { mode: "fixed", alpha: 0.5 } }).alpha).toEqual({ mode: "fixed", alpha: 0.5 });
-        expect(normalizeQuery({ role: "bg.canvas", alpha: { mode: "solveOnBackground" } }).alpha).toEqual({ mode: "solveOnBackground" });
-        expect(() => normalizeQuery({ role: "bg.canvas", alpha: { mode: "fixed" } })).toThrowError(/fixed alpha/i);
-        expect(() => normalizeQuery({ role: "bg.canvas", alpha: { mode: "nope" } })).toThrowError(/alpha strategy mode/i);
-    });
-});

package/dist/engine/onSolid.d.ts

@@ -1,3 +0,0 @@
-import type { OnSolidQuery } from "../types/index.js";
-import type { BaseResolvedColor, ThemeConfig } from "./resolveBaseColor.js";
-export declare function onSolid(query: OnSolidQuery, theme: ThemeConfig): BaseResolvedColor;

package/dist/engine/onSolid.js

@@ -1,110 +0,0 @@
-import { computeApcaLc } from "../contrast/apca.js";
-import { solveContrast } from "../contrast/solver.js";
-import { blendSrgb, toSrgbColor } from "../contrast/utils.js";
-import { contrastRatio } from "../contrast/wcag2.js";
-import { applyOperators } from "./applyOperators.js";
-import { mapColorContextToEngine } from "./context.js";
-import { normalizeOnSolidQuery, normalizeQuery } from "./normalize.js";
-import { resolveBaseColor } from "./resolveBaseColor.js";
-const DEFAULT_SOLVE_EPSILON = 0.01;
-const nearWhite = { l: 97, c: 0, h: 0, alpha: 1 };
-const nearBlack = { l: 15, c: 0, h: 0, alpha: 1 };
-const defaultContrastForUsage = (usage) => ({
-    model: "apca",
-    targetLc: usage === "text" ? 75 : 60,
-});
-const validateFixedAlpha = (alpha) => {
-    if (alpha < 0 || alpha > 1) {
-        throw new Error("Fixed alpha must be between 0 and 1");
-    }
-    return alpha;
-};
-const resolveAlphaStrategy = (alpha, usage, strict) => {
-    if (!alpha) {
-        return { mode: "fixed", alpha: usage === "text" ? 0.92 : 0.72 };
-    }
-    if (alpha.mode === "none") {
-        return alpha;
-    }
-    if (alpha.mode === "fixed") {
-        return { mode: "fixed", alpha: validateFixedAlpha(alpha.alpha) };
-    }
-    if (strict) {
-        throw new Error('onSolid does not support alpha.mode "solveOnBackground"');
-    }
-    console.warn('onSolid does not support alpha.mode "solveOnBackground"; falling back to fixed defaults');
-    return { mode: "fixed", alpha: usage === "text" ? 0.92 : 0.72 };
-};
-const checkContrastWithAlpha = (fg, bg, req, alpha, epsilon = DEFAULT_SOLVE_EPSILON) => {
-    if (req.model === "none") {
-        return { pass: true, value: 0 };
-    }
-    const fgSrgb = toSrgbColor(fg);
-    const bgSrgb = toSrgbColor(bg);
-    if (!fgSrgb || !bgSrgb) {
-        return { pass: false, value: Number.NaN };
-    }
-    const composite = blendSrgb(fgSrgb, bgSrgb, alpha);
-    if (req.model === "apca") {
-        const value = Math.abs(computeApcaLc(composite, bgSrgb));
-        const minTarget = req.minLc ?? req.targetLc;
-        const maxTarget = req.maxLc ?? Number.POSITIVE_INFINITY;
-        return {
-            pass: Number.isFinite(value) && value >= minTarget - epsilon && value <= maxTarget + epsilon,
-            value,
-        };
-    }
-    const value = contrastRatio(composite, bgSrgb);
-    return { pass: Number.isFinite(value) && value + epsilon >= req.minRatio, value };
-};
-export function onSolid(query, theme) {
-    const normalized = normalizeOnSolidQuery(query);
-    const contrastRequirement = normalized.contrast ?? defaultContrastForUsage(normalized.usage);
-    const alphaStrategy = resolveAlphaStrategy(normalized.alpha, normalized.usage, normalized.output.strict);
-    const alpha = alphaStrategy.mode === "none" ? 1 : alphaStrategy.alpha;
-    const bgNormalized = normalizeQuery({
-        role: normalized.bgRole,
-        usage: "bg",
-        surface: "solid",
-        context: normalized.context,
-        state: normalized.state,
-        emphasis: normalized.emphasis,
-    });
-    const bgBase = resolveBaseColor(bgNormalized, theme);
-    // Apply state/emphasis operators to the background before onSolid solves.
-    const bgResolved = applyOperators(bgBase, bgNormalized, theme);
-    const bg = bgResolved.oklch;
-    const baseFg = bg.l >= 50 ? nearBlack : nearWhite;
-    const seedUsed = `oklch(${baseFg.l}% ${baseFg.c} ${baseFg.h})`;
-    const solverContext = {
-        preset: theme.preset,
-        surface: bgNormalized.surface,
-        context: mapColorContextToEngine(bgNormalized.context),
-    };
-    const solved = solveContrast({ ...baseFg, alpha }, bg, contrastRequirement, solverContext, {
-        strict: normalized.output.strict,
-    });
-    let finalAlpha = alpha;
-    let finalColor = solved.color;
-    let finalCheck = checkContrastWithAlpha(finalColor, bg, contrastRequirement, finalAlpha, DEFAULT_SOLVE_EPSILON);
-    if (!finalCheck.pass && finalAlpha < 1) {
-        finalAlpha = 1;
-        const solvedOpaque = solveContrast({ ...baseFg, alpha: 1 }, bg, contrastRequirement, solverContext, { strict: normalized.output.strict });
-        finalColor = solvedOpaque.color;
-        finalCheck = checkContrastWithAlpha(finalColor, bg, contrastRequirement, finalAlpha, DEFAULT_SOLVE_EPSILON);
-    }
-    if (!finalCheck.pass && normalized.output.strict) {
-        const target = contrastRequirement.model === "apca"
-            ? contrastRequirement.targetLc
-            : contrastRequirement.model === "wcag2"
-                ? contrastRequirement.minRatio
-                : 0;
-        throw new Error(`onSolid contrast failed (${contrastRequirement.model}) target=${target} value=${finalCheck.value}`);
-    }
-    return {
-        oklch: { ...finalColor, alpha: finalAlpha },
-        step: 0,
-        variantUsed: "onSolid",
-        seedUsed,
-    };
-}

package/dist/engine/resolveBaseColor.d.ts

@@ -1,25 +0,0 @@
-import type { CurvePresetName } from "../presets/index.js";
-import type { ColorQuery, CssColorString } from "../types/index.js";
-import { type OkLchColor } from "./generateScale.js";
-import type { NormalizedQuery } from "./normalize.js";
-type ThemeSeeds = {
-    neutral: CssColorString;
-    accent: CssColorString;
-};
-export type ThemeConfig = {
-    seeds: {
-        light: ThemeSeeds;
-        dark: ThemeSeeds;
-    };
-    variants?: Record<string, CssColorString>;
-    preset?: CurvePresetName;
-};
-export type BaseResolvedColor = {
-    oklch: OkLchColor;
-    step: number;
-    variantUsed: string;
-    seedUsed: CssColorString;
-};
-export declare function resolveBaseColor(query: ColorQuery, theme: ThemeConfig): BaseResolvedColor;
-export declare function resolveBaseColor(normalized: NormalizedQuery, theme: ThemeConfig): BaseResolvedColor;
-export {};