@clhaas/palette-kit 0.1.8 → 0.3.0

package/dist/core/onSolid.test.js

@@ -0,0 +1,118 @@
+import { describe, expect, it, vi } from "vitest";
+import * as apca from "../contrast/apca.js";
+import { blendSrgb, toSrgbColor } from "../contrast/utils.js";
+import * as operators from "../engine/applyOperators.js";
+import { createTheme } from "./createTheme.js";
+const passesApca = (fg, bg, targetLc, alpha = 1) => {
+    const fgSrgb = toSrgbColor(fg);
+    const bgSrgb = toSrgbColor(bg);
+    if (!fgSrgb || !bgSrgb) {
+        return false;
+    }
+    const composite = blendSrgb(fgSrgb, bgSrgb, alpha);
+    const value = Math.abs(apca.computeApcaLc(composite, bgSrgb));
+    return value >= targetLc;
+};
+const theme = createTheme({
+    seeds: {
+        light: { neutral: "#8B8D98", accent: "#3D63DD" },
+        dark: { neutral: "#8B8D98", accent: "#3D63DD" },
+    },
+    preset: "modern",
+});
+describe("onSolid", () => {
+    it("chooses a white-ish foreground on dark solids", () => {
+        const bg = theme.resolve({
+            role: "action.primary",
+            usage: "bg",
+            surface: "solid",
+            context: "dark",
+        });
+        const result = theme.onSolid({
+            bgRole: "action.primary",
+            usage: "text",
+            context: "dark",
+        });
+        expect(bg.oklch.l).toBeLessThan(50);
+        expect(result.oklch.l).toBeGreaterThan(50);
+        expect(passesApca(result.oklch, bg.oklch, 75, result.oklch.alpha ?? 1)).toBe(true);
+    });
+    it("chooses a black-ish foreground on light solids", () => {
+        const bg = theme.resolve({
+            role: "action.primary",
+            usage: "bg",
+            surface: "solid",
+            context: "light",
+        });
+        const result = theme.onSolid({
+            bgRole: "action.primary",
+            usage: "icon",
+            context: "light",
+        });
+        expect(bg.oklch.l).toBeGreaterThanOrEqual(50);
+        expect(result.oklch.l).toBeLessThan(50);
+        expect(passesApca(result.oklch, bg.oklch, 60, result.oklch.alpha ?? 1)).toBe(true);
+    });
+    it("raises alpha to 1 when needed for contrast", () => {
+        const bg = theme.resolve({
+            role: "action.primary",
+            usage: "bg",
+            surface: "solid",
+            context: "dark",
+        });
+        const result = theme.onSolid({
+            bgRole: "action.primary",
+            usage: "icon",
+            context: "dark",
+            contrast: { model: "apca", targetLc: 90 },
+        });
+        expect(result.oklch.alpha).toBe(1);
+        expect(passesApca(result.oklch, bg.oklch, 90, 1)).toBe(true);
+        expect(passesApca(result.oklch, bg.oklch, 90, 0.72)).toBe(false);
+    });
+    it("throws in strict mode when contrast is impossible", () => {
+        expect(() => theme.onSolid({
+            bgRole: "action.primary",
+            usage: "text",
+            context: "light",
+            contrast: { model: "apca", targetLc: 140 },
+            output: { strict: true },
+        })).toThrow(/onSolid contrast failed|Contrast solver failed/i);
+    });
+    it("accepts results within epsilon for strict checks", () => {
+        const spy = vi.spyOn(apca, "computeApcaLc").mockImplementation(() => 74.995);
+        try {
+            expect(() => theme.onSolid({
+                bgRole: "action.primary",
+                usage: "text",
+                context: "light",
+                contrast: { model: "apca", targetLc: 75 },
+                output: { strict: true },
+            })).not.toThrow();
+        }
+        finally {
+            spy.mockRestore();
+        }
+    });
+    it("keeps alpha at 1 when mode is none", () => {
+        const result = theme.onSolid({
+            bgRole: "action.primary",
+            usage: "text",
+            context: "dark",
+            alpha: { mode: "none" },
+        });
+        expect(result.oklch.alpha).toBe(1);
+    });
+    it("applies state and emphasis to the background before solving", () => {
+        const spy = vi.spyOn(operators, "applyOperators");
+        theme.onSolid({
+            bgRole: "action.primary",
+            usage: "text",
+            context: "light",
+            state: "hover",
+            emphasis: "strong",
+        });
+        expect(spy).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ state: "hover", emphasis: "strong" }), expect.any(Object));
+        spy.mockRestore();
+    });
+});

package/dist/core/qa.v1.test.d.ts

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

package/dist/core/qa.v1.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { serializeColor } from "../export/serializeColor.js";
+import { createTheme } from "./createTheme.js";
+const buildTheme = () => createTheme({
+    seeds: {
+        light: { neutral: "#111827", accent: "#3d63dd" },
+        dark: { neutral: "#111827", accent: "#3d63dd" },
+    },
+});
+const toOklchString = (oklch) => serializeColor(oklch, { preferSpace: "oklch", includeMeta: true });
+describe("QA v1", () => {
+    it("resolves light/dark background without NaNs", () => {
+        const theme = buildTheme();
+        const light = theme.resolve({
+            role: "bg.app",
+            usage: "bg",
+            context: "light",
+            surface: "app",
+        });
+        const dark = theme.resolve({
+            role: "bg.app",
+            usage: "bg",
+            context: "dark",
+            surface: "app",
+        });
+        const lightSerialized = toOklchString(light.oklch);
+        const darkSerialized = toOklchString(dark.oklch);
+        expect(typeof lightSerialized.value).toBe("string");
+        expect(lightSerialized.value.includes("oklch(")).toBe(true);
+        expect(Number.isFinite(lightSerialized.alpha)).toBe(true);
+        expect(lightSerialized.alpha).toBeGreaterThanOrEqual(0);
+        expect(lightSerialized.alpha).toBeLessThanOrEqual(1);
+        expect(typeof darkSerialized.value).toBe("string");
+        expect(darkSerialized.value.includes("oklch(")).toBe(true);
+        expect(Number.isFinite(darkSerialized.alpha)).toBe(true);
+        expect(darkSerialized.alpha).toBeGreaterThanOrEqual(0);
+        expect(darkSerialized.alpha).toBeLessThanOrEqual(1);
+    });
+    it("solves primary/secondary text on solid backgrounds", () => {
+        const theme = buildTheme();
+        const primary = theme.onSolid({
+            bgRole: "action.primary",
+            usage: "text",
+            context: "light",
+            contrast: { model: "apca", targetLc: 75 },
+        });
+        const secondary = theme.onSolid({
+            bgRole: "action.primary",
+            usage: "text",
+            context: "light",
+            contrast: { model: "apca", targetLc: 60 },
+        });
+        const primarySerialized = toOklchString(primary.oklch);
+        const secondarySerialized = toOklchString(secondary.oklch);
+        expect(primarySerialized.value).not.toBe("");
+        expect(primarySerialized.alpha).toBeGreaterThanOrEqual(0);
+        expect(primarySerialized.alpha).toBeLessThanOrEqual(1);
+        expect(secondarySerialized.value).not.toBe("");
+        expect(secondarySerialized.alpha).toBeGreaterThanOrEqual(0);
+        expect(secondarySerialized.alpha).toBeLessThanOrEqual(1);
+    });
+    it("handles solid button states and onSolid text", () => {
+        const theme = buildTheme();
+        const base = {
+            role: "action.primary",
+            usage: "bg",
+            surface: "solid",
+            context: "light",
+        };
+        const states = ["default", "hover", "active"];
+        const serializedStates = states.map((state) => toOklchString(theme.resolve({ ...base, state }).oklch).value);
+        serializedStates.forEach((value) => {
+            expect(value.startsWith("oklch(")).toBe(true);
+        });
+        const onSolidText = toOklchString(theme.onSolid({ bgRole: "action.primary", usage: "text", context: "light" }).oklch);
+        expect(onSolidText.alpha).toBeGreaterThanOrEqual(0.85);
+        expect(onSolidText.alpha).toBeLessThanOrEqual(1);
+    });
+    it("produces a distinct focus ring color with meta", () => {
+        const theme = buildTheme();
+        const ring = toOklchString(theme.resolve({
+            role: "focus.ring",
+            variant: "accent",
+            usage: "ring",
+            context: "light",
+            surface: "surface",
+            contrast: { model: "apca", targetLc: 45 },
+        }).oklch);
+        const surface = toOklchString(theme.resolve({
+            role: "surface.card",
+            usage: "bg",
+            context: "light",
+            surface: "surface",
+        }).oklch);
+        expect(ring.value).not.toBe(surface.value);
+        expect(ring.meta?.gamutMapping).toBeDefined();
+    });
+    it("keeps overlay scrim alpha stable", () => {
+        const theme = buildTheme();
+        const scrim = toOklchString(theme.resolve({
+            role: "overlay.scrim",
+            usage: "bg",
+            surface: "overlay",
+            context: "dark",
+            alpha: { mode: "fixed", alpha: 0.55 },
+        }).oklch);
+        expect(scrim.alpha).toBeGreaterThanOrEqual(0);
+        expect(scrim.alpha).toBeLessThanOrEqual(1);
+        expect(scrim.value.includes("oklch(")).toBe(true);
+        expect(scrim.value.includes("NaN")).toBe(false);
+    });
+});

package/dist/core/resolve.d.ts

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

package/dist/core/resolve.js

@@ -0,0 +1,8 @@
+import { applyOperators } from "../engine/applyOperators.js";
+import { normalizeQuery } from "../engine/normalize.js";
+import { resolveBaseColor } from "../engine/resolveBaseColor.js";
+export function resolve(query, theme) {
+    const normalized = normalizeQuery(query);
+    const base = resolveBaseColor(normalized, theme);
+    return applyOperators(base, normalized, theme);
+}

package/dist/core/resolve.test.d.ts

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

package/dist/core/resolve.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { createTheme } from "./createTheme.js";
+const theme = createTheme({
+    seeds: {
+        light: { neutral: "#8B8D98", accent: "#3D63DD" },
+        dark: { neutral: "#8B8D98", accent: "#3D63DD" },
+    },
+    preset: "modern",
+});
+describe("resolve", () => {
+    it("applies state operators via theme.resolve", () => {
+        const baseLight = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "light",
+        });
+        const hoverLight = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "light",
+            state: "hover",
+        });
+        const baseDark = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "dark",
+        });
+        const hoverDark = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "dark",
+            state: "hover",
+        });
+        const activeDark = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "dark",
+            state: "active",
+        });
+        const activeLight = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "light",
+            state: "active",
+        });
+        const disabledLight = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "light",
+            state: "disabled",
+        });
+        const disabledDark = theme.resolve({
+            role: "bg.solid",
+            usage: "bg",
+            surface: "solid",
+            context: "dark",
+            state: "disabled",
+        });
+        expect(hoverLight.oklch.l).toBeLessThan(baseLight.oklch.l);
+        expect(hoverDark.oklch.l).toBeGreaterThan(baseDark.oklch.l);
+        expect(Math.abs(activeLight.oklch.l - baseLight.oklch.l)).toBeGreaterThan(Math.abs(hoverLight.oklch.l - baseLight.oklch.l));
+        expect(Math.abs(activeDark.oklch.l - baseDark.oklch.l)).toBeGreaterThan(Math.abs(hoverDark.oklch.l - baseDark.oklch.l));
+        expect(disabledLight.oklch.c).toBeLessThan(baseLight.oklch.c * 0.6);
+        expect(disabledDark.oklch.c).toBeLessThan(baseDark.oklch.c * 0.6);
+    });
+    it("applies emphasis via theme.resolve", () => {
+        const base = theme.resolve({
+            role: "text.primary",
+            usage: "text",
+            surface: "surface",
+            context: "light",
+        });
+        const muted = theme.resolve({
+            role: "text.primary",
+            usage: "text",
+            surface: "surface",
+            context: "light",
+            emphasis: "muted",
+        });
+        expect(muted.oklch.c).toBeLessThan(base.oklch.c);
+    });
+});

package/dist/core/resolveMany.d.ts

@@ -0,0 +1,8 @@
+import type { BaseResolvedColor, ThemeConfig } from "../engine/resolveBaseColor.js";
+import type { ColorQuery } from "../types/index.js";
+/**
+ * Resolve a batch of color queries while preserving input order.
+ *
+ * Convenience helper to resolve multiple color queries in a single call.
+ */
+export declare function resolveMany(queries: ColorQuery[], theme: ThemeConfig): BaseResolvedColor[];

package/dist/core/resolveMany.js

@@ -0,0 +1,17 @@
+import { applyOperators } from "../engine/applyOperators.js";
+import { normalizeQuery } from "../engine/normalize.js";
+import { resolveBaseColor } from "../engine/resolveBaseColor.js";
+/**
+ * Resolve a batch of color queries while preserving input order.
+ *
+ * Convenience helper to resolve multiple color queries in a single call.
+ */
+export function resolveMany(queries, theme) {
+    const results = [];
+    for (const query of queries) {
+        const normalized = normalizeQuery(query);
+        const base = resolveBaseColor(normalized, theme);
+        results.push(applyOperators(base, normalized, theme));
+    }
+    return results;
+}

package/dist/core/tokenRegistry.d.ts

@@ -0,0 +1,23 @@
+import type { BaseResolvedColor } from "../engine/resolveBaseColor.js";
+import type { TokenDefinition, TokenRegistry } from "../types/index.js";
+import type { PaletteTheme } from "./createTheme.js";
+/**
+ * Validate a token definition for safe registry usage.
+ *
+ * Guarantees (Phase 3):
+ * - registry stays declarative (no output options / no embedded color literals)
+ * - tokens are base tokens (interactive states declared via `token.states`)
+ */
+export declare const validateTokenDefinition: (token: TokenDefinition) => void;
+/**
+ * Validate a token registry and each token definition it contains.
+ */
+export declare const validateTokenRegistry: (registry: TokenRegistry) => void;
+/**
+ * Resolve a token definition through the provided theme.
+ */
+export declare const resolveToken: (token: TokenDefinition, theme: PaletteTheme) => BaseResolvedColor;
+/**
+ * Resolve all tokens in a registry while preserving key order.
+ */
+export declare const resolveTokenRegistry: (registry: TokenRegistry, theme: PaletteTheme) => Record<string, BaseResolvedColor>;

package/dist/core/tokenRegistry.js

@@ -0,0 +1,83 @@
+import { COLOR_STATES, normalizeQuery } from "../engine/normalize.js";
+const ALLOWED_TOKEN_STATES = COLOR_STATES.filter((state) => state !== "default");
+const validateTokenStates = (states, name) => {
+    if (!states)
+        return;
+    for (const [state, enabled] of Object.entries(states)) {
+        if (enabled !== true) {
+            throw new Error(`Token "${name}" state "${state}" must be true`);
+        }
+        if (!ALLOWED_TOKEN_STATES.includes(state)) {
+            throw new Error(`Invalid token state "${state}" for "${name}"`);
+        }
+    }
+};
+/**
+ * Validate a token definition for safe registry usage.
+ *
+ * Guarantees (Phase 3):
+ * - registry stays declarative (no output options / no embedded color literals)
+ * - tokens are base tokens (interactive states declared via `token.states`)
+ */
+export const validateTokenDefinition = (token) => {
+    if (typeof token.name !== "string" || !token.name.trim()) {
+        throw new Error("Token name is required");
+    }
+    if (typeof token.query?.role !== "string" || !token.query.role.trim()) {
+        throw new Error(`Token "${token.name}" requires a query role`);
+    }
+    if (!token.query.usage) {
+        throw new Error(`Token "${token.name}" requires a usage`);
+    }
+    if (!token.query.surface) {
+        throw new Error(`Token "${token.name}" requires a surface`);
+    }
+    const rawState = token.query.state;
+    const normalizedState = typeof rawState === "string" ? rawState.trim() : rawState;
+    if (normalizedState && normalizedState !== "default") {
+        throw new Error(`Token "${token.name}" must not encode state in query; declare supported states via token.states`);
+    }
+    const onKind = token.query.on?.kind;
+    if (onKind === "color") {
+        throw new Error(`Token "${token.name}" must not include a literal background color hint; use { kind: "role" } or { kind: "auto" }`);
+    }
+    if (token.query.output) {
+        throw new Error(`Token "${token.name}" must not include output options`);
+    }
+    validateTokenStates(token.states, token.name);
+    // Delegate to core validation for strict field validation.
+    normalizeQuery({ ...token.query, output: { strict: true } });
+};
+/**
+ * Validate a token registry and each token definition it contains.
+ */
+export const validateTokenRegistry = (registry) => {
+    const entries = Object.entries(registry.tokens);
+    if (entries.length === 0) {
+        throw new Error("Token registry must include at least one token");
+    }
+    for (const [name, token] of entries) {
+        if (token.name !== name) {
+            throw new Error(`Token name mismatch: expected "${name}", got "${token.name}"`);
+        }
+        validateTokenDefinition(token);
+    }
+};
+/**
+ * Resolve a token definition through the provided theme.
+ */
+export const resolveToken = (token, theme) => {
+    validateTokenDefinition(token);
+    return theme.resolve(token.query);
+};
+/**
+ * Resolve all tokens in a registry while preserving key order.
+ */
+export const resolveTokenRegistry = (registry, theme) => {
+    validateTokenRegistry(registry);
+    const resolved = {};
+    for (const [name, token] of Object.entries(registry.tokens)) {
+        resolved[name] = theme.resolve(token.query);
+    }
+    return resolved;
+};

package/dist/core/tokenRegistry.test.d.ts

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

package/dist/core/tokenRegistry.test.js

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+import { createTheme } from "./createTheme.js";
+import { resolveToken, resolveTokenRegistry, validateTokenRegistry } from "./tokenRegistry.js";
+describe("token registry", () => {
+    const theme = createTheme({
+        seeds: {
+            light: { neutral: "#8B8D98", accent: "#3D63DD" },
+            dark: { neutral: "#8B8D98", accent: "#3D63DD" },
+        },
+        preset: "modern",
+    });
+    it("validates tokens and resolves through theme.resolve", () => {
+        const registry = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    description: "App background",
+                    category: "background",
+                    query: { role: "bg.app", usage: "bg", surface: "app" },
+                    states: { hover: true },
+                },
+            },
+        };
+        validateTokenRegistry(registry);
+        const resolved = resolveTokenRegistry(registry, theme);
+        expect(resolved["bg.app"].step).toBeGreaterThan(0);
+        const single = resolveToken(registry.tokens["bg.app"], theme);
+        const expected = theme.resolve(registry.tokens["bg.app"].query);
+        expect(single.step).toBe(expected.step);
+    });
+    it("throws when required query fields are missing", () => {
+        const registry = {
+            tokens: {
+                "text.primary": {
+                    name: "text.primary",
+                    query: { role: "text.primary", usage: "text" },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(registry)).toThrow(/requires a surface/i);
+    });
+    it("throws when output options are provided", () => {
+        const registry = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: {
+                        role: "bg.app",
+                        usage: "bg",
+                        surface: "app",
+                        output: { strict: true },
+                    },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(registry)).toThrow(/must not include output/i);
+    });
+    it("treats whitespace-padded default state as default", () => {
+        const registry = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: {
+                        role: "bg.app",
+                        usage: "bg",
+                        surface: "app",
+                        state: " default ",
+                    },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(registry)).not.toThrow();
+    });
+    it("throws when token query encodes a non-default state", () => {
+        const registry = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: { role: "bg.app", usage: "bg", surface: "app", state: "hover" },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(registry)).toThrow(/must not encode state/i);
+    });
+    it("throws when token query includes a literal background color hint", () => {
+        const registry = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: {
+                        role: "bg.app",
+                        usage: "bg",
+                        surface: "app",
+                        on: { kind: "color", value: "#fff" },
+                    },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(registry)).toThrow(/literal background color/i);
+    });
+    it("throws when token states include invalid keys or non-true values", () => {
+        const invalidKey = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: { role: "bg.app", usage: "bg", surface: "app" },
+                    states: { nope: true },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(invalidKey)).toThrow(/Invalid token state/i);
+        const includesDefault = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: { role: "bg.app", usage: "bg", surface: "app" },
+                    states: { default: true },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(includesDefault)).toThrow(/Invalid token state/i);
+        const nonTrueValue = {
+            tokens: {
+                "bg.app": {
+                    name: "bg.app",
+                    query: { role: "bg.app", usage: "bg", surface: "app" },
+                    states: { hover: false },
+                },
+            },
+        };
+        expect(() => validateTokenRegistry(nonTrueValue)).toThrow(/must be true/i);
+    });
+});

package/dist/engine/applyOperators.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedQuery } from "./normalize.js";
+import type { BaseResolvedColor, ThemeConfig } from "./resolveBaseColor.js";
+export declare const applyOperators: (base: BaseResolvedColor, normalized: NormalizedQuery, theme: ThemeConfig) => BaseResolvedColor;

package/dist/engine/applyOperators.js

@@ -0,0 +1,23 @@
+import { applyEmphasisOperator } from "../operators/emphasis.js";
+import { applyStateOperator } from "../operators/state.js";
+import { mapColorContextToEngine } from "./context.js";
+export const applyOperators = (base, normalized, theme) => {
+    const context = mapColorContextToEngine(normalized.context);
+    const operatorInput = {
+        oklch: base.oklch,
+        context,
+        surface: normalized.surface,
+        usage: normalized.usage,
+        state: normalized.state,
+        emphasis: normalized.emphasis,
+        preset: theme.preset,
+        step: base.step,
+    };
+    // Emphasis defines the baseline hierarchy; state applies transient interaction.
+    const emphasized = applyEmphasisOperator(operatorInput);
+    const stated = applyStateOperator({ ...operatorInput, oklch: emphasized });
+    return {
+        ...base,
+        oklch: stated,
+    };
+};

package/dist/engine/context.d.ts

@@ -0,0 +1,4 @@
+import type { ColorContext } from "../types/index.js";
+import type { NormalizedQuery } from "./normalize.js";
+export type EngineContext = "light" | "dark";
+export declare const mapColorContextToEngine: (context: ColorContext | NormalizedQuery["context"]) => EngineContext;

package/dist/engine/context.js

@@ -0,0 +1 @@
+export const mapColorContextToEngine = (context) => (context === "dark" || context === "dimmed" ? "dark" : "light");

package/dist/engine/gamut.d.ts

@@ -0,0 +1,13 @@
+import type { OutputOptions } from "../types/index.js";
+import type { OkLchColor } from "./generateScale.js";
+export type GamutTarget = "srgb" | "p3";
+export type GamutMapping = NonNullable<OutputOptions["gamutMapping"]>;
+type GamutRgb = {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare const isInGamut: (color: OkLchColor, target: GamutTarget) => boolean;
+export declare const mapToGamut: (color: OkLchColor, target: GamutTarget, mapping: GamutMapping, strict: boolean) => OkLchColor;
+export declare const toGamutRgb: (color: OkLchColor, target: GamutTarget) => GamutRgb | null;
+export {};