@clhaas/palette-kit 0.3.0 → 0.4.0

package/dist/engine/resolveBaseColor.js

@@ -1,127 +0,0 @@
-import { parseColor } from "../utils/parseColor.js";
-import { mapColorContextToEngine } from "./context.js";
-import { generateScale } from "./generateScale.js";
-import { normalizeQuery } from "./normalize.js";
-const isCategoryVariant = (variant) => variant.startsWith("category:");
-const isChartVariant = (variant) => variant.startsWith("chart:");
-const aliasVariants = new Set(["success", "warning", "danger", "info"]);
-const inferVariantFromRole = (role) => {
-    const normalizedRole = role.toLowerCase();
-    if (normalizedRole.startsWith("action.")) {
-        return "accent";
-    }
-    if (normalizedRole.startsWith("bg.") ||
-        normalizedRole.startsWith("surface.") ||
-        normalizedRole.startsWith("border.") ||
-        normalizedRole.startsWith("text.")) {
-        return "neutral";
-    }
-    return "neutral";
-};
-const resolveVariantSeed = (variant, role, config, contextKey) => {
-    if (variant) {
-        if (variant === "neutral" || variant === "accent") {
-            return {
-                variantUsed: variant,
-                seedUsed: config.seeds[contextKey][variant],
-            };
-        }
-        if (isCategoryVariant(variant) || isChartVariant(variant)) {
-            const customSeed = config.variants?.[variant];
-            if (customSeed) {
-                return { variantUsed: variant, seedUsed: customSeed };
-            }
-            return { variantUsed: "accent", seedUsed: config.seeds[contextKey].accent };
-        }
-        if (aliasVariants.has(variant)) {
-            return { variantUsed: "accent", seedUsed: config.seeds[contextKey].accent };
-        }
-        return { variantUsed: "accent", seedUsed: config.seeds[contextKey].accent };
-    }
-    const inferredVariant = inferVariantFromRole(role);
-    return {
-        variantUsed: inferredVariant,
-        seedUsed: config.seeds[contextKey][inferredVariant],
-    };
-};
-const clampStep = (value) => Math.min(12, Math.max(1, value));
-const resolveStep = (usage, surface) => {
-    switch (usage) {
-        case "bg": {
-            switch (surface) {
-                case "app":
-                    return 1;
-                case "surface":
-                    return 2;
-                case "subtle":
-                    return 3;
-                case "solid":
-                    return 9;
-                case "overlay":
-                    return 2;
-                case "data":
-                    return 9;
-                case "transparent":
-                    return 1;
-                default:
-                    return 2;
-            }
-        }
-        case "border": {
-            switch (surface) {
-                case "solid":
-                case "data":
-                    return 8;
-                default:
-                    return 6;
-            }
-        }
-        case "text":
-            return 11;
-        case "icon":
-            return 11;
-        case "ring":
-            return 8;
-        case "stroke":
-            return surface === "data" ? 9 : 8;
-        case "fill":
-            return 9;
-        default:
-            return 6;
-    }
-};
-// Best-effort guard: ColorQuery may include state/emphasis already; a branded flag
-// from normalizeQuery would be the strict approach in a future version.
-const isNormalizedQuery = (value) => typeof value === "object" &&
-    value !== null &&
-    typeof value.role === "string" &&
-    typeof value.usage === "string" &&
-    typeof value.surface === "string" &&
-    typeof value.context === "string" &&
-    typeof value.state === "string" &&
-    typeof value.emphasis === "string";
-export function resolveBaseColor(query, theme) {
-    const normalized = isNormalizedQuery(query) ? query : normalizeQuery(query);
-    const contextKey = mapColorContextToEngine(normalized.context);
-    const { variantUsed, seedUsed } = resolveVariantSeed(normalized.variant, normalized.role, theme, contextKey);
-    const parsedSeed = parseColor(seedUsed);
-    const seed = {
-        l: parsedSeed.okLch.channels[0] * 100,
-        c: parsedSeed.okLch.channels[1],
-        h: parsedSeed.okLch.channels[2],
-        alpha: parsedSeed.okLch.alpha,
-    };
-    const scale = generateScale(seed, {
-        context: contextKey,
-        surface: normalized.surface,
-        preset: theme.preset,
-    });
-    const step = clampStep(resolveStep(normalized.usage, normalized.surface));
-    const oklch = scale[step - 1];
-    return {
-        oklch,
-        step,
-        variantUsed,
-        seedUsed,
-    };
-}

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

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

package/dist/engine/resolveBaseColor.test.js

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseColor } from "../utils/parseColor.js";
-import { normalizeQuery } from "./normalize.js";
-import { resolveBaseColor } from "./resolveBaseColor.js";
-const themeConfig = {
-    seeds: {
-        light: { neutral: "#8B8D98", accent: "#3D63DD" },
-        dark: { neutral: "#8B8D98", accent: "#3D63DD" },
-    },
-    variants: {
-        "category:food": "#C2410C",
-    },
-    preset: "modern",
-};
-describe("resolveBaseColor", () => {
-    const r = (query) => resolveBaseColor(normalizeQuery(query), themeConfig);
-    it("defaults action roles to accent when variant is missing", () => {
-        const result = r({
-            role: "action.primary",
-            usage: "bg",
-            surface: "solid",
-            context: "light",
-        });
-        expect(result.variantUsed).toBe("accent");
-        expect(result.seedUsed).toBe(themeConfig.seeds.light.accent);
-    });
-    it("defaults text roles to neutral when variant is missing", () => {
-        const result = r({
-            role: "text.primary",
-            usage: "text",
-            surface: "surface",
-            context: "light",
-        });
-        expect(result.variantUsed).toBe("neutral");
-        expect(result.seedUsed).toBe(themeConfig.seeds.light.neutral);
-    });
-    it("uses custom category variants when provided", () => {
-        const result = r({
-            role: "bg.category",
-            variant: "category:food",
-            usage: "bg",
-            surface: "surface",
-            context: "light",
-        });
-        expect(result.variantUsed).toBe("category:food");
-        expect(result.seedUsed).toBe(themeConfig.variants?.["category:food"]);
-    });
-    it("falls back to accent for missing category variants", () => {
-        const result = r({
-            role: "bg.category",
-            variant: "category:missing",
-            usage: "bg",
-            surface: "surface",
-            context: "light",
-        });
-        expect(result.variantUsed).toBe("accent");
-        expect(result.seedUsed).toBe(themeConfig.seeds.light.accent);
-    });
-    it("chooses steps based on usage and surface", () => {
-        const appBg = r({ role: "bg.app", usage: "bg", surface: "app", context: "light" });
-        const solidBg = r({ role: "bg.solid", usage: "bg", surface: "solid", context: "light" });
-        const borderSurface = r({
-            role: "border.surface",
-            usage: "border",
-            surface: "surface",
-            context: "light",
-        });
-        const ring = r({ role: "ring.focus", usage: "ring", surface: "surface", context: "light" });
-        expect(appBg.step).toBe(1);
-        expect(solidBg.step).toBe(9);
-        expect(borderSurface.step).toBe(6);
-        expect(ring.step).toBe(8);
-    });
-    it("returns valid OKLCH values with stable hue", () => {
-        const result = r({
-            role: "action.primary",
-            usage: "bg",
-            surface: "solid",
-            context: "light",
-        });
-        const seed = parseColor(themeConfig.seeds.light.accent);
-        expect(result.oklch.l).toBeGreaterThanOrEqual(0);
-        expect(result.oklch.l).toBeLessThanOrEqual(100);
-        expect(result.oklch.c).toBeGreaterThanOrEqual(0);
-        expect(result.oklch.h).toBeCloseTo(seed.okLch.channels[2], 6);
-    });
-    it("accepts normalized queries without re-normalizing", () => {
-        const normalized = normalizeQuery({
-            role: "text.secondary",
-            usage: "text",
-            surface: "surface",
-            context: "dark",
-        });
-        const result = resolveBaseColor(normalized, themeConfig);
-        expect(result.step).toBe(11);
-    });
-});

package/dist/export/__snapshots__/exportTheme.test.js.snap

@@ -1,74 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`exportTheme > exports deterministic CSS with @supports overrides 1`] = `
-":root {
-  --pk-bg-app: #dddee1;
-  --pk-custom-alias: #f1f4fb;
-  --pk-text-primary: #f1f4fb;
-}
-
-@supports (color: oklch(0% 0 0)) {
-  :root {
-    --pk-bg-app: oklch(90% 0.004 264.7);
-    --pk-bg-app-oklch: oklch(90% 0.004 264.7);
-    --pk-custom-alias: oklch(96.7% 0.01 264.7);
-    --pk-custom-alias-oklch: oklch(96.7% 0.01 264.7);
-    --pk-text-primary: oklch(96.7% 0.01 264.7);
-    --pk-text-primary-oklch: oklch(96.7% 0.01 264.7);
-  }
-}
-
-@supports (color: color(display-p3 1 1 1)) {
-  :root {
-    --pk-bg-app-p3: color(display-p3 0.866 0.87 0.88);
-    --pk-custom-alias-p3: color(display-p3 0.947 0.957 0.981);
-    --pk-text-primary-p3: color(display-p3 0.947 0.957 0.981);
-  }
-}
-"
-`;
-
-exports[`exportTheme > exports deterministic JSON with light/dark contexts 1`] = `
-{
-  "dark": {
-    "bg.app": {
-      "alpha": 1,
-      "oklch": "oklch(6% 0.004 264.7)",
-      "srgb": "#010101",
-      "value": "oklch(6% 0.004 264.7)",
-    },
-    "custom.alias": {
-      "alpha": 1,
-      "oklch": "oklch(27.5% 0.01 264.7)",
-      "srgb": "#25282d",
-      "value": "oklch(27.5% 0.01 264.7)",
-    },
-    "text.primary": {
-      "alpha": 1,
-      "oklch": "oklch(27.5% 0.01 264.7)",
-      "srgb": "#25282d",
-      "value": "oklch(27.5% 0.01 264.7)",
-    },
-  },
-  "light": {
-    "bg.app": {
-      "alpha": 1,
-      "oklch": "oklch(90% 0.004 264.7)",
-      "srgb": "#dddee1",
-      "value": "oklch(90% 0.004 264.7)",
-    },
-    "custom.alias": {
-      "alpha": 1,
-      "oklch": "oklch(96.7% 0.01 264.7)",
-      "srgb": "#f1f4fb",
-      "value": "oklch(96.7% 0.01 264.7)",
-    },
-    "text.primary": {
-      "alpha": 1,
-      "oklch": "oklch(96.7% 0.01 264.7)",
-      "srgb": "#f1f4fb",
-      "value": "oklch(96.7% 0.01 264.7)",
-    },
-  },
-}
-`;

package/dist/export/exportTheme.d.ts

@@ -1,47 +0,0 @@
-import type { OkLchColor } from "../engine/generateScale.js";
-import type { ColorMeta, ColorQuery, OutputOptions } from "../types/index.js";
-export type ThemeToken = Omit<ColorQuery, "role" | "output"> & {
-    role?: string;
-};
-export type ThemeTokens = Record<string, ThemeToken>;
-export type ExportableTheme = {
-    resolve: (query: ColorQuery) => {
-        oklch: OkLchColor;
-    };
-};
-export type TokenValue = {
-    value: string;
-    srgb?: string;
-    p3?: string;
-    oklch?: string;
-    alpha: number;
-    meta?: ColorMeta;
-};
-export type ExportMeta = {
-    gamutMapping: NonNullable<OutputOptions["gamutMapping"]>;
-    preferSpace: NonNullable<OutputOptions["preferSpace"]>;
-    includeSpaces: NonNullable<OutputOptions["includeSpaces"]>;
-    precision: Required<NonNullable<OutputOptions["precision"]>>;
-    srgbFormat: NonNullable<OutputOptions["srgbFormat"]>;
-    strict: boolean;
-};
-/**
- * Export CSS variables for a token map with progressive fallbacks.
- *
- * - Base output uses sRGB for maximum compatibility.
- * - @supports blocks override the main token value with OKLCH and/or P3 as requested.
- */
-export declare const exportThemeCss: (theme: ExportableTheme, tokens: ThemeTokens, output?: OutputOptions) => {
-    css: string;
-    meta: ExportMeta | undefined;
-};
-/**
- * Export JSON tokens for both light and dark contexts.
- */
-export declare const exportThemeJson: (theme: ExportableTheme, tokens: ThemeTokens, output?: OutputOptions) => {
-    tokens: {
-        light: Record<string, TokenValue>;
-        dark: Record<string, TokenValue>;
-    };
-    meta: ExportMeta | undefined;
-};

package/dist/export/exportTheme.js

@@ -1,170 +0,0 @@
-import { serializeColorJson } from "../serialize/serializeColor.js";
-import { serializeColor } from "./serializeColor.js";
-const DEFAULT_OUTPUT = {
-    preferSpace: "oklch",
-    includeSpaces: [],
-    gamutMapping: "preferP3ThenCompress",
-    precision: { l: 1, c: 3, h: 1, alpha: 2 },
-    srgbFormat: "hex",
-    strict: false,
-    includeMeta: false,
-};
-const normalizeExportOutput = (output) => ({
-    preferSpace: output?.preferSpace ?? DEFAULT_OUTPUT.preferSpace,
-    includeSpaces: output?.includeSpaces ?? DEFAULT_OUTPUT.includeSpaces,
-    gamutMapping: output?.gamutMapping ?? DEFAULT_OUTPUT.gamutMapping,
-    precision: {
-        ...DEFAULT_OUTPUT.precision,
-        ...output?.precision,
-    },
-    srgbFormat: output?.srgbFormat ?? DEFAULT_OUTPUT.srgbFormat,
-    strict: output?.strict ?? DEFAULT_OUTPUT.strict,
-    includeMeta: output?.includeMeta ?? DEFAULT_OUTPUT.includeMeta,
-});
-const buildExportMeta = (output) => ({
-    gamutMapping: output.gamutMapping,
-    preferSpace: output.preferSpace,
-    includeSpaces: output.includeSpaces,
-    precision: output.precision,
-    srgbFormat: output.srgbFormat,
-    strict: output.strict,
-});
-const getTokenEntries = (tokens) => {
-    if (!tokens || Object.keys(tokens).length === 0) {
-        throw new Error("Theme tokens are required for export");
-    }
-    return Object.entries(tokens).sort(([a], [b]) => a.localeCompare(b));
-};
-const getTokenRole = (name, token) => token.role ?? name;
-const buildTokenQuery = (name, token, context) => {
-    const { role: _role, ...rest } = token;
-    return {
-        ...rest,
-        role: getTokenRole(name, token),
-        ...(context ? { context } : {}),
-    };
-};
-const buildTokenMeta = (name, token, context) => ({
-    role: getTokenRole(name, token),
-    ...(token.variant ? { variant: token.variant } : {}),
-    ...(token.usage ? { usage: token.usage } : {}),
-    ...(context ? { context } : token.context ? { context: token.context } : {}),
-    ...(token.surface ? { surface: token.surface } : {}),
-    ...(token.state ? { state: token.state } : {}),
-    ...(token.emphasis ? { emphasis: token.emphasis } : {}),
-    ...(token.on ? { on: token.on } : {}),
-    ...(token.contrast ? { contrast: token.contrast } : {}),
-});
-const buildTokenValue = (serialized) => ({
-    value: serialized.value,
-    ...(serialized.srgb !== undefined ? { srgb: serialized.srgb } : {}),
-    ...(serialized.p3 !== undefined ? { p3: serialized.p3 } : {}),
-    ...(serialized.oklch !== undefined ? { oklch: serialized.oklch } : {}),
-    alpha: serialized.alpha,
-    ...(serialized.meta !== undefined ? { meta: serialized.meta } : {}),
-});
-const toCssVarName = (name) => name.replace(/\./g, "-");
-const indent = (lines, prefix) => lines.length === 0 ? "" : lines.map((line) => `${prefix}${line}`).join("\n");
-/**
- * Export CSS variables for a token map with progressive fallbacks.
- *
- * - Base output uses sRGB for maximum compatibility.
- * - @supports blocks override the main token value with OKLCH and/or P3 as requested.
- */
-export const exportThemeCss = (theme, tokens, output) => {
-    const normalized = normalizeExportOutput(output);
-    const entries = getTokenEntries(tokens);
-    const baseDecl = [];
-    const oklchDecl = [];
-    const p3Decl = [];
-    const needsOklch = normalized.preferSpace === "oklch" || normalized.includeSpaces.includes("oklch");
-    const needsP3 = normalized.preferSpace === "p3" || normalized.includeSpaces.includes("p3");
-    for (const [name, token] of entries) {
-        const query = buildTokenQuery(name, token);
-        const resolved = theme.resolve(query);
-        const meta = normalized.includeMeta ? buildTokenMeta(name, token) : undefined;
-        const baseName = toCssVarName(name);
-        // Base fallback MUST be sRGB (no silent OKLCH fallback).
-        const baseSrgb = serializeColor(resolved.oklch, { ...normalized, preferSpace: "srgb", includeSpaces: [], strict: normalized.strict }, meta).value;
-        baseDecl.push(`--pk-${baseName}: ${baseSrgb};`);
-        if (normalized.includeSpaces.includes("srgb")) {
-            baseDecl.push(`--pk-${baseName}-srgb: ${baseSrgb};`);
-        }
-        if (needsOklch) {
-            const oklchValue = serializeColor(resolved.oklch, { ...normalized, preferSpace: "oklch", includeSpaces: [] }, meta).value;
-            if (normalized.preferSpace === "oklch") {
-                oklchDecl.push(`--pk-${baseName}: ${oklchValue};`);
-            }
-            if (normalized.includeSpaces.includes("oklch")) {
-                oklchDecl.push(`--pk-${baseName}-oklch: ${oklchValue};`);
-            }
-        }
-        if (needsP3) {
-            const p3Text = serializeColor(resolved.oklch, { ...normalized, preferSpace: "oklch", includeSpaces: ["p3"] }, meta).p3;
-            if (normalized.preferSpace === "p3") {
-                if (!p3Text) {
-                    if (normalized.strict) {
-                        throw new Error("Unable to serialize preferred space: p3");
-                    }
-                }
-                else {
-                    p3Decl.push(`--pk-${baseName}: ${p3Text};`);
-                }
-            }
-            if (normalized.includeSpaces.includes("p3") && p3Text) {
-                p3Decl.push(`--pk-${baseName}-p3: ${p3Text};`);
-            }
-        }
-    }
-    const blocks = [];
-    blocks.push(`:root {\n${indent(baseDecl, "  ")}\n}\n`);
-    if (oklchDecl.length > 0) {
-        blocks.push(`@supports (color: oklch(0% 0 0)) {\n  :root {\n${indent(oklchDecl, "    ")}\n  }\n}\n`);
-    }
-    if (p3Decl.length > 0) {
-        blocks.push(`@supports (color: color(display-p3 1 1 1)) {\n  :root {\n${indent(p3Decl, "    ")}\n  }\n}\n`);
-    }
-    return {
-        css: `${blocks.join("\n").trimEnd()}\n`,
-        meta: normalized.includeMeta ? buildExportMeta(normalized) : undefined,
-    };
-};
-/**
- * Export JSON tokens for both light and dark contexts.
- */
-export const exportThemeJson = (theme, tokens, output) => {
-    const normalized = normalizeExportOutput(output);
-    const entries = getTokenEntries(tokens);
-    const lightTokens = {};
-    const darkTokens = {};
-    const contexts = ["light", "dark"];
-    for (const [name, token] of entries) {
-        for (const context of contexts) {
-            const query = buildTokenQuery(name, token, context);
-            const resolved = theme.resolve(query);
-            const meta = normalized.includeMeta ? buildTokenMeta(name, token, context) : undefined;
-            const serialized = serializeColorJson(resolved.oklch, normalized, meta);
-            const entry = buildTokenValue({
-                value: serialized.value,
-                srgb: serialized.srgb,
-                p3: serialized.p3,
-                oklch: serialized.oklch,
-                alpha: serialized.alpha,
-                meta: serialized.meta,
-            });
-            if (context === "light") {
-                lightTokens[name] = entry;
-            }
-            else {
-                darkTokens[name] = entry;
-            }
-        }
-    }
-    return {
-        tokens: {
-            light: lightTokens,
-            dark: darkTokens,
-        },
-        meta: normalized.includeMeta ? buildExportMeta(normalized) : undefined,
-    };
-};

package/dist/export/exportTheme.test.d.ts

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

package/dist/export/exportTheme.test.js

@@ -1,118 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createTheme } from "../core/createTheme.js";
-import * as gamut from "../engine/gamut.js";
-import { exportThemeCss, exportThemeJson } from "./exportTheme.js";
-const buildTheme = () => {
-    const theme = createTheme({
-        seeds: {
-            light: { neutral: "#111827", accent: "#3d63dd" },
-            dark: { neutral: "#111827", accent: "#3d63dd" },
-        },
-    });
-    const tokens = {
-        "text.primary": {
-            usage: "text",
-            surface: "surface",
-            emphasis: "default",
-        },
-        "bg.app": {
-            usage: "bg",
-            surface: "app",
-        },
-        "custom.alias": {
-            role: "text.primary",
-            usage: "text",
-            surface: "surface",
-        },
-    };
-    return {
-        resolve: theme.resolve.bind(theme),
-        tokens,
-    };
-};
-describe("exportTheme", () => {
-    it("throws when theme tokens are missing", () => {
-        const theme = createTheme({
-            seeds: {
-                light: { neutral: "#111827", accent: "#3d63dd" },
-                dark: { neutral: "#111827", accent: "#3d63dd" },
-            },
-        });
-        expect(() => exportThemeCss(theme, {})).toThrow(/Theme tokens are required for export/i);
-        expect(() => exportThemeJson(theme, {})).toThrow(/Theme tokens are required for export/i);
-    });
-    it("exports deterministic CSS with @supports overrides", () => {
-        const theme = buildTheme();
-        const { css } = exportThemeCss(theme, theme.tokens, {
-            preferSpace: "oklch",
-            includeSpaces: ["p3", "oklch"],
-        });
-        expect(css).toMatchSnapshot();
-    });
-    it("includes meta when requested and omits when not", () => {
-        const theme = buildTheme();
-        const withMeta = exportThemeJson(theme, theme.tokens, { includeMeta: true });
-        expect(withMeta.tokens.light["bg.app"].meta?.gamutMapping).toBe("preferP3ThenCompress");
-        expect(withMeta.meta).toEqual({
-            gamutMapping: "preferP3ThenCompress",
-            preferSpace: "oklch",
-            includeSpaces: [],
-            precision: { l: 1, c: 3, h: 1, alpha: 2 },
-            srgbFormat: "hex",
-            strict: false,
-        });
-        const withoutMeta = exportThemeJson(theme, theme.tokens, { includeMeta: false });
-        expect(withoutMeta.tokens.light["bg.app"].meta).toBeUndefined();
-    });
-    it("includes export meta for CSS when requested", () => {
-        const theme = buildTheme();
-        const { meta } = exportThemeCss(theme, theme.tokens, { includeMeta: true });
-        expect(meta).toEqual({
-            gamutMapping: "preferP3ThenCompress",
-            preferSpace: "oklch",
-            includeSpaces: [],
-            precision: { l: 1, c: 3, h: 1, alpha: 2 },
-            srgbFormat: "hex",
-            strict: false,
-        });
-    });
-    it("exports deterministic JSON with light/dark contexts", () => {
-        const theme = buildTheme();
-        const { tokens } = exportThemeJson(theme, theme.tokens, {
-            preferSpace: "oklch",
-            includeSpaces: ["srgb"],
-        });
-        expect(tokens).toMatchSnapshot();
-    });
-    it("keeps ordering stable regardless of token map order", () => {
-        const theme = buildTheme();
-        const shuffled = {
-            "custom.alias": theme.tokens["custom.alias"],
-            "bg.app": theme.tokens["bg.app"],
-            "text.primary": theme.tokens["text.primary"],
-        };
-        const cssA = exportThemeCss(theme, theme.tokens, { preferSpace: "oklch" }).css;
-        const cssB = exportThemeCss(theme, shuffled, { preferSpace: "oklch" }).css;
-        const jsonA = exportThemeJson(theme, theme.tokens, { preferSpace: "oklch" }).tokens;
-        const jsonB = exportThemeJson(theme, shuffled, { preferSpace: "oklch" }).tokens;
-        expect(cssA).toBe(cssB);
-        expect(jsonA).toEqual(jsonB);
-    });
-    it("throws when strict preferred space cannot be serialized", () => {
-        const theme = buildTheme();
-        const original = gamut.toGamutRgb;
-        const spy = vi
-            .spyOn(gamut, "toGamutRgb")
-            .mockImplementation((color, target) => (target === "p3" ? null : original(color, target)));
-        try {
-            expect(() => exportThemeCss(theme, theme.tokens, {
-                preferSpace: "p3",
-                includeSpaces: ["p3"],
-                strict: true,
-            })).toThrow(/Unable to serialize preferred space: p3/i);
-        }
-        finally {
-            spy.mockRestore();
-        }
-    });
-});

package/dist/export/index.d.ts

@@ -1 +0,0 @@
-export * from "./exportTheme.js";

package/dist/export/index.js

@@ -1 +0,0 @@
-export * from "./exportTheme.js";

package/dist/export/serializeColor.d.ts

@@ -1 +0,0 @@
-export { serializeColor } from "../serialize/serializeColor.js";

package/dist/export/serializeColor.js

@@ -1 +0,0 @@
-export { serializeColor } from "../serialize/serializeColor.js";

package/dist/export/serializeColor.test.d.ts

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