@clhaas/palette-kit 0.3.0 → 0.4.0

package/dist/contrast/utils.d.ts

@@ -1,4 +0,0 @@
-import type { OkLchColor } from "../engine/generateScale.js";
-import type { SrgbColor } from "./types.js";
-export declare const toSrgbColor: (color: OkLchColor) => SrgbColor | null;
-export declare const blendSrgb: (fg: SrgbColor, bg: SrgbColor, alpha: number) => SrgbColor;

package/dist/contrast/utils.js

@@ -1,18 +0,0 @@
-import { converter } from "culori";
-const toSrgb = converter("rgb");
-const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-export 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 };
-};
-export const blendSrgb = (fg, bg, alpha) => ({
-    r: fg.r * alpha + bg.r * (1 - alpha),
-    g: fg.g * alpha + bg.g * (1 - alpha),
-    b: fg.b * alpha + bg.b * (1 - alpha),
-});

package/dist/contrast/wcag2.d.ts

@@ -1,3 +0,0 @@
-import type { SrgbColor } from "./types.js";
-export declare const relativeLuminance: (color: SrgbColor) => number;
-export declare const contrastRatio: (fg: SrgbColor, bg: SrgbColor) => number;

package/dist/contrast/wcag2.js

@@ -1,19 +0,0 @@
-const clamp01 = (value) => Math.min(1, Math.max(0, value));
-const toLinear = (channel) => {
-    const value = clamp01(channel);
-    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
-};
-export const relativeLuminance = (color) => {
-    const r = toLinear(color.r);
-    const g = toLinear(color.g);
-    const b = toLinear(color.b);
-    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-};
-export const contrastRatio = (fg, bg) => {
-    const fgLum = relativeLuminance(fg);
-    const bgLum = relativeLuminance(bg);
-    const lighter = Math.max(fgLum, bgLum);
-    const darker = Math.min(fgLum, bgLum);
-    const ratio = (lighter + 0.05) / (darker + 0.05);
-    return Number.isFinite(ratio) ? ratio : Number.NaN;
-};

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

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

package/dist/contrast/wcag2.test.js

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { contrastRatio } from "./wcag2.js";
-describe("wcag2 contrastRatio", () => {
-    it("returns high contrast for black on white", () => {
-        const ratio = contrastRatio({ r: 0, g: 0, b: 0 }, { r: 1, g: 1, b: 1 });
-        expect(ratio).toBeGreaterThan(10);
-    });
-    it("returns lower contrast for mid gray on white", () => {
-        const gray = 0x77 / 255;
-        const ratio = contrastRatio({ r: gray, g: gray, b: gray }, { r: 1, g: 1, b: 1 });
-        expect(ratio).toBeLessThan(4.5);
-    });
-    it("does not return NaN", () => {
-        const ratio = contrastRatio({ r: 0.2, g: 0.4, b: 0.6 }, { r: 0.8, g: 0.7, b: 0.1 });
-        expect(Number.isNaN(ratio)).toBe(false);
-    });
-});

package/dist/core/createTheme.d.ts

@@ -1,35 +0,0 @@
-import type { BaseResolvedColor, ThemeConfig } from "../engine/resolveBaseColor.js";
-import type { ColorContext, ColorQuery, ColorRole, OnSolidQuery, OutputOptions, ResolvedColor } from "../types/index.js";
-export type PaletteTheme = {
-    /**
-     * Resolve a single color query to the core OKLCH output shape.
-     */
-    resolve: (query: ColorQuery) => BaseResolvedColor;
-    /**
-     * Resolve a batch of color queries while preserving input order.
-     */
-    resolveMany: (queries: ColorQuery[]) => BaseResolvedColor[];
-    /**
-     * Resolve a color role with inference and DX validation.
-     *
-     * Inference and strict/non-strict behavior is shared with `theme.resolve(...)` and is
-     * implemented inside query normalization.
-     *
-     * When `output.strict` is true, missing inference throws an error; otherwise
-     * safe defaults are used.
-     */
-    color: (role: ColorRole, options?: Omit<ColorQuery, "role">) => BaseResolvedColor;
-    /**
-     * Resolve a foreground color against a solid background (APCA/WCAG aware).
-     */
-    onSolid: (query: OnSolidQuery) => BaseResolvedColor;
-    /**
-     * Serialize a resolved color query for external outputs (CSS, RN, JSON, etc.).
-     */
-    serialize: (query: ColorQuery, options?: OutputOptions) => ResolvedColor;
-    /**
-     * Return a new theme instance with a bound context.
-     */
-    withContext: (context: ColorContext) => PaletteTheme;
-};
-export declare function createTheme(config: ThemeConfig): PaletteTheme;

package/dist/core/createTheme.js

@@ -1,24 +0,0 @@
-import { onSolid } from "../engine/onSolid.js";
-import { serializeResolved } from "../serialize/serializeColor.js";
-import { resolve } from "./resolve.js";
-import { resolveMany } from "./resolveMany.js";
-export function createTheme(config) {
-    const themeConfig = {
-        ...config,
-        preset: config.preset ?? "modern",
-        variants: config.variants ?? {},
-    };
-    const applyBoundContext = (query, boundContext) => (boundContext ? { context: boundContext, ...query } : query);
-    const buildTheme = (boundContext) => ({
-        resolve: (query) => resolve(applyBoundContext(query, boundContext), themeConfig),
-        resolveMany: (queries) => resolveMany(queries.map((query) => applyBoundContext(query, boundContext)), themeConfig),
-        color: (role, options) => resolve(applyBoundContext({ role, ...(options ?? {}) }, boundContext), themeConfig),
-        onSolid: (query) => onSolid(applyBoundContext(query, boundContext), themeConfig),
-        serialize: (query, options) => {
-            const resolved = resolve(applyBoundContext(query, boundContext), themeConfig);
-            return serializeResolved(resolved, options);
-        },
-        withContext: (context) => buildTheme(context),
-    });
-    return buildTheme();
-}

package/dist/core/dx-helpers.test.d.ts

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

package/dist/core/dx-helpers.test.js

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTheme } from "./createTheme.js";
-describe("Phase 2 helpers", () => {
-    const theme = createTheme({
-        seeds: {
-            light: { neutral: "#8B8D98", accent: "#3D63DD" },
-            dark: { neutral: "#8B8D98", accent: "#3D63DD" },
-        },
-        preset: "modern",
-    });
-    it("resolveMany preserves input order", () => {
-        const queries = [
-            { role: "bg.app", usage: "bg", surface: "app", context: "light" },
-            { role: "text.primary", usage: "text", surface: "surface", context: "light" },
-        ];
-        const expected = queries.map((query) => theme.resolve(query));
-        const results = theme.resolveMany(queries);
-        expect(results.map((result) => result.step)).toEqual(expected.map((result) => result.step));
-        expect(results.map((result) => result.seedUsed)).toEqual(expected.map((result) => result.seedUsed));
-    });
-    it("withContext applies bound context and allows overrides", () => {
-        const darkTheme = theme.withContext("dark");
-        const bound = darkTheme.resolve({ role: "bg.app", usage: "bg", surface: "app" });
-        const explicit = {
-            role: "bg.app",
-            usage: "bg",
-            surface: "app",
-            context: "dark",
-        };
-        const explicitResolved = theme.resolve(explicit);
-        expect(bound.step).toBe(explicitResolved.step);
-        const override = darkTheme.resolve({
-            role: "bg.app",
-            usage: "bg",
-            surface: "app",
-            context: "light",
-        });
-        const light = {
-            role: "bg.app",
-            usage: "bg",
-            surface: "app",
-            context: "light",
-        };
-        const lightResolved = theme.resolve(light);
-        expect(override.step).toBe(lightResolved.step);
-    });
-    it("theme.color infers usage and surface from role", () => {
-        const inferred = theme.color("bg.app");
-        const explicit = theme.resolve({ role: "bg.app", usage: "bg", surface: "app" });
-        expect(inferred.step).toBe(explicit.step);
-        expect(inferred.seedUsed).toBe(explicit.seedUsed);
-    });
-    it("theme.color throws in strict mode when inference is missing", () => {
-        expect(() => theme.color("custom.role", {
-            output: { strict: true },
-        })).toThrow(/Usage is required for role/i);
-        expect(() => theme.color("text.custom", {
-            output: { strict: true },
-        })).toThrow(/Surface is required for role/i);
-    });
-});

package/dist/core/index.d.ts

@@ -1,2 +0,0 @@
-export { createTheme } from "./createTheme.js";
-export { resolveToken, resolveTokenRegistry, validateTokenDefinition, validateTokenRegistry, } from "./tokenRegistry.js";

package/dist/core/index.js

@@ -1,2 +0,0 @@
-export { createTheme } from "./createTheme.js";
-export { resolveToken, resolveTokenRegistry, validateTokenDefinition, validateTokenRegistry, } from "./tokenRegistry.js";

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

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

package/dist/core/onSolid.test.js

@@ -1,118 +0,0 @@
-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

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

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

@@ -1,112 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/dist/core/resolve.test.js

@@ -1,89 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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>;