@clhaas/palette-kit 0.1.0 → 0.1.2

package/dist/exporters/toCssVars.js

@@ -0,0 +1,84 @@
+import Color from "colorjs.io";
+function tokenToCssVar(token, prefix) {
+    const normalized = token.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    const dashed = normalized.replace(/\./g, "-");
+    return `--${prefix}-${dashed}`;
+}
+function scaleToCssVar(slot, step, prefix) {
+    return `--${prefix}-scale-${slot}-${step}`;
+}
+function alphaToCssVar(step, prefix) {
+    return `--${prefix}-alpha-${step}`;
+}
+function hexToP3(value) {
+    return new Color(value).to("p3").toString({ format: "color" });
+}
+export function toCssVars(theme, options) {
+    const prefix = options?.prefix ?? "pk";
+    const includeTokens = options?.includeTokens ?? true;
+    const includeScales = options?.includeScales ?? true;
+    const includeAlpha = options?.includeAlpha ?? true;
+    const includeP3 = options?.includeP3 ?? false;
+    const lightSelector = options?.lightSelector ?? ":root";
+    const darkSelector = options?.darkSelector ?? ".dark";
+    const lines = [];
+    const hasP3 = Object.values(theme.scales).some((scale) => scale.p3);
+    function emitSelector(selector, mode) {
+        lines.push(`${selector} {`);
+        if (includeTokens) {
+            for (const [token, value] of Object.entries(theme.tokens[mode])) {
+                lines.push(`  ${tokenToCssVar(token, prefix)}: ${value};`);
+            }
+        }
+        if (includeScales) {
+            for (const [slot, scale] of Object.entries(theme.scales)) {
+                for (const [step, value] of Object.entries(scale[mode])) {
+                    lines.push(`  ${scaleToCssVar(slot, Number(step), prefix)}: ${value};`);
+                }
+            }
+        }
+        if (includeAlpha && theme.alpha) {
+            for (const [step, value] of Object.entries(theme.alpha[mode])) {
+                lines.push(`  ${alphaToCssVar(Number(step), prefix)}: ${value};`);
+            }
+        }
+        lines.push("}");
+    }
+    emitSelector(lightSelector, "light");
+    lines.push("");
+    emitSelector(darkSelector, "dark");
+    if (includeP3 && hasP3) {
+        lines.push("");
+        lines.push("@supports (color: color(display-p3 1 1 1)) {");
+        function emitP3Selector(selector, mode) {
+            lines.push(`  ${selector} {`);
+            if (includeTokens) {
+                for (const [token, value] of Object.entries(theme.tokens[mode])) {
+                    lines.push(`    ${tokenToCssVar(token, prefix)}: ${hexToP3(value)};`);
+                }
+            }
+            if (includeScales) {
+                for (const [slot, scale] of Object.entries(theme.scales)) {
+                    const p3Scale = scale.p3?.[mode];
+                    if (!p3Scale) {
+                        continue;
+                    }
+                    for (const [step, value] of Object.entries(p3Scale)) {
+                        lines.push(`    ${scaleToCssVar(slot, Number(step), prefix)}: ${value};`);
+                    }
+                }
+            }
+            if (includeAlpha && theme.alpha) {
+                for (const [step, value] of Object.entries(theme.alpha[mode])) {
+                    lines.push(`    ${alphaToCssVar(Number(step), prefix)}: ${hexToP3(value)};`);
+                }
+            }
+            lines.push("  }");
+        }
+        emitP3Selector(lightSelector, "light");
+        lines.push("");
+        emitP3Selector(darkSelector, "dark");
+        lines.push("}");
+    }
+    return lines.join("\n");
+}

package/dist/exporters/toJson.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from "../types.js";
+export declare function toJson(theme: Theme): string;
+export declare function toJsonWithMode(theme: Theme, mode: "srgb" | "p3"): string;

package/dist/exporters/toJson.js

@@ -0,0 +1,25 @@
+export function toJson(theme) {
+    return JSON.stringify(theme, null, 2);
+}
+export function toJsonWithMode(theme, mode) {
+    if (mode === "p3") {
+        return JSON.stringify(toP3Theme(theme), null, 2);
+    }
+    return JSON.stringify(theme, null, 2);
+}
+function toP3Theme(theme) {
+    const scales = Object.fromEntries(Object.entries(theme.scales).map(([slot, scale]) => {
+        if (!scale.p3) {
+            return [slot, scale];
+        }
+        return [
+            slot,
+            {
+                ...scale,
+                light: scale.p3.light,
+                dark: scale.p3.dark,
+            },
+        ];
+    }));
+    return { ...theme, scales };
+}

package/dist/exporters/toReactNative.d.ts

@@ -0,0 +1,30 @@
+import type { Theme } from "../types.js";
+type ReactNativeOptions = {
+    includeTokens?: boolean;
+    includeScales?: boolean;
+    includeAlpha?: boolean;
+    includeP3?: boolean;
+};
+export declare function toReactNative(theme: Theme, options?: ReactNativeOptions): {
+    light: {
+        tokens: Record<string, `#${string}`>;
+        scales: {
+            [k: string]: Record<import("../types.js").Step, `#${string}`>;
+        };
+        alpha: Record<import("../types.js").Step, `#${string}`> | undefined;
+        p3: {
+            [k: string]: Record<import("../types.js").Step, string> | undefined;
+        } | undefined;
+    };
+    dark: {
+        tokens: Record<string, `#${string}`>;
+        scales: {
+            [k: string]: Record<import("../types.js").Step, `#${string}`>;
+        };
+        alpha: Record<import("../types.js").Step, `#${string}`> | undefined;
+        p3: {
+            [k: string]: Record<import("../types.js").Step, string> | undefined;
+        } | undefined;
+    };
+};
+export {};

package/dist/exporters/toReactNative.js

@@ -0,0 +1,26 @@
+export function toReactNative(theme, options) {
+    const includeTokens = options?.includeTokens ?? true;
+    const includeScales = options?.includeScales ?? true;
+    const includeAlpha = options?.includeAlpha ?? true;
+    const includeP3 = options?.includeP3 ?? false;
+    function buildMode(mode) {
+        const scales = includeScales
+            ? Object.fromEntries(Object.entries(theme.scales).map(([slot, scale]) => [slot, scale[mode]]))
+            : {};
+        const p3 = includeP3
+            ? Object.fromEntries(Object.entries(theme.scales)
+                .filter(([, scale]) => scale.p3?.[mode])
+                .map(([slot, scale]) => [slot, scale.p3?.[mode]]))
+            : undefined;
+        return {
+            tokens: includeTokens ? theme.tokens[mode] : {},
+            scales,
+            alpha: includeAlpha ? theme.alpha?.[mode] : undefined,
+            p3,
+        };
+    }
+    return {
+        light: buildMode("light"),
+        dark: buildMode("dark"),
+    };
+}

package/dist/exporters/toTailwind.d.ts

@@ -0,0 +1,16 @@
+import type { Theme } from "../types.js";
+type TailwindOptions = {
+    mode?: "light" | "dark" | "both";
+    includeTokens?: boolean;
+    includeScales?: boolean;
+    includeAlpha?: boolean;
+    includeP3?: boolean;
+};
+export declare function toTailwind(theme: Theme, options?: TailwindOptions): {
+    theme: {
+        extend: {
+            colors: Record<string, unknown>;
+        };
+    };
+};
+export {};

package/dist/exporters/toTailwind.js

@@ -0,0 +1,90 @@
+function setNested(target, path, value) {
+    let cursor = target;
+    for (let i = 0; i < path.length - 1; i += 1) {
+        const key = path[i];
+        if (!cursor[key] || typeof cursor[key] !== "object") {
+            cursor[key] = {};
+        }
+        cursor = cursor[key];
+    }
+    cursor[path[path.length - 1]] = value;
+}
+function tokensToNested(tokens) {
+    const output = {};
+    for (const [token, value] of Object.entries(tokens)) {
+        setNested(output, token.split("."), value);
+    }
+    return output;
+}
+function scalesToNested(scales, mode, useP3) {
+    const output = {};
+    for (const [slot, scale] of Object.entries(scales)) {
+        const source = useP3 ? scale.p3?.[mode] : scale[mode];
+        if (!source) {
+            continue;
+        }
+        const stepMap = {};
+        for (const [step, value] of Object.entries(source)) {
+            stepMap[String(step)] = value;
+        }
+        output[slot] = stepMap;
+    }
+    return output;
+}
+function alphaToNested(alpha, mode) {
+    if (!alpha) {
+        return undefined;
+    }
+    const output = {};
+    for (const [step, value] of Object.entries(alpha[mode])) {
+        output[String(step)] = value;
+    }
+    return output;
+}
+export function toTailwind(theme, options) {
+    const mode = options?.mode ?? "both";
+    const includeTokens = options?.includeTokens ?? true;
+    const includeScales = options?.includeScales ?? false;
+    const includeAlpha = options?.includeAlpha ?? false;
+    const includeP3 = options?.includeP3 ?? false;
+    function buildModeTokens(modeKey, useP3) {
+        const colors = {};
+        if (includeTokens) {
+            colors.tokens = tokensToNested(theme.tokens[modeKey]);
+        }
+        if (includeScales) {
+            colors.scale = scalesToNested(theme.scales, modeKey, useP3);
+        }
+        if (includeAlpha && theme.alpha) {
+            colors.alpha = alphaToNested(theme.alpha, modeKey);
+        }
+        return colors;
+    }
+    const colors = {};
+    if (mode === "light" || mode === "both") {
+        colors.light = buildModeTokens("light");
+    }
+    if (mode === "dark" || mode === "both") {
+        colors.dark = buildModeTokens("dark");
+    }
+    if (includeP3) {
+        const hasP3 = Object.values(theme.scales).some((scale) => scale.p3);
+        if (hasP3) {
+            const p3 = {};
+            if (mode === "light" || mode === "both") {
+                p3.light = buildModeTokens("light", true);
+            }
+            if (mode === "dark" || mode === "both") {
+                p3.dark = buildModeTokens("dark", true);
+            }
+            colors.p3 = p3;
+        }
+    }
+    return {
+        theme: {
+            extend: {
+                colors,
+            },
+        },
+    };
+}

package/dist/exporters/toTs.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from "../types.js";
+export declare function toTs(theme: Theme): string;
+export declare function toTsWithMode(theme: Theme, mode: "srgb" | "p3"): string;

package/dist/exporters/toTs.js

@@ -0,0 +1,28 @@
+export function toTs(theme) {
+    const serialized = JSON.stringify(theme, null, 2);
+    return `export const theme = ${serialized} as const;\n`;
+}
+export function toTsWithMode(theme, mode) {
+    if (mode === "p3") {
+        const serialized = JSON.stringify(toP3Theme(theme), null, 2);
+        return `export const theme = ${serialized} as const;\n`;
+    }
+    const serialized = JSON.stringify(theme, null, 2);
+    return `export const theme = ${serialized} as const;\n`;
+}
+function toP3Theme(theme) {
+    const scales = Object.fromEntries(Object.entries(theme.scales).map(([slot, scale]) => {
+        if (!scale.p3) {
+            return [slot, scale];
+        }
+        return [
+            slot,
+            {
+                ...scale,
+                light: scale.p3.light,
+                dark: scale.p3.dark,
+            },
+        ];
+    }));
+    return { ...theme, scales };
+}

package/dist/generateScale.d.ts

@@ -0,0 +1,48 @@
+import { type CurveConfig } from "./engine/curves.js";
+import type { ColorSource, Scale, Step, TemplateId } from "./types.js";
+export type AnchorStepOption = Step | "auto" | {
+    light?: Step | "auto";
+    dark?: Step | "auto";
+};
+export type AutoAnchorModeOptions = {
+    candidateSteps?: Step[];
+    backgroundStep?: Step;
+    backgroundSteps?: Step[];
+    solidStep?: Step;
+    textStep?: Step;
+    targetContrast?: number;
+    minBackgroundL?: number;
+    maxBackgroundL?: number;
+    minTextL?: number;
+    maxTextL?: number;
+};
+export type AutoAnchorOptions = {
+    candidateSteps?: Step[];
+    light?: AutoAnchorModeOptions;
+    dark?: AutoAnchorModeOptions;
+};
+export type SeedNormalizeRange = {
+    minL?: number;
+    maxL?: number;
+    minC?: number;
+    maxC?: number;
+};
+export type SeedNormalizeOptions = {
+    enabled?: boolean;
+    light?: SeedNormalizeRange;
+    dark?: SeedNormalizeRange;
+};
+export type GenerateScaleOptions = {
+    source: ColorSource;
+    mode?: "light" | "dark" | "both";
+    anchorStep?: AnchorStepOption;
+    autoAnchor?: AutoAnchorOptions;
+    seedNormalize?: SeedNormalizeOptions;
+    template?: "auto" | TemplateId;
+    curves?: CurveConfig;
+    gamut?: {
+        strategy: "compress" | "clip";
+    };
+    p3?: boolean;
+};
+export declare function generateScale(options: GenerateScaleOptions): Scale;

package/dist/generateScale.js

@@ -0,0 +1,274 @@
+import { apcaContrast } from "./contrast/apca.js";
+import { onSolidTextTokens } from "./contrast/onSolid.js";
+import { radixSeeds } from "./data/radixSeeds.js";
+import { resolveCurves } from "./engine/curves.js";
+import { compressToP3, compressToSrgb, hexToOklch, inP3Gamut, inSrgbGamut, oklchToHex, oklchToP3, } from "./engine/oklch.js";
+import { selectTemplateId, templates } from "./engine/templates.js";
+const steps = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+const defaultAutoAnchor = {
+    candidateSteps: [8, 9, 10],
+    light: {
+        backgroundStep: 1,
+        backgroundSteps: [1, 2, 3],
+        solidStep: 9,
+        textStep: 12,
+        targetContrast: 90,
+        minBackgroundL: 0.86,
+        maxBackgroundL: 0.98,
+        minTextL: 0.22,
+        maxTextL: 0.55,
+    },
+    dark: {
+        backgroundStep: 1,
+        backgroundSteps: [1, 2, 3],
+        solidStep: 9,
+        textStep: 12,
+        targetContrast: 75,
+        minBackgroundL: 0.1,
+        maxBackgroundL: 0.32,
+        minTextL: 0.75,
+        maxTextL: 0.98,
+    },
+};
+const defaultSeedNormalize = {
+    light: {
+        minL: 0.35,
+        maxL: 0.9,
+    },
+    dark: {
+        minL: 0.32,
+        maxL: 0.82,
+    },
+};
+function getSeedHex(source) {
+    if (source.source === "seed") {
+        return source.value;
+    }
+    const seed = radixSeeds[source.name];
+    if (!seed) {
+        throw new Error(`Unknown Radix seed: ${source.name}`);
+    }
+    return seed;
+}
+function normalizeHue(hue) {
+    const normalized = ((hue % 360) + 360) % 360;
+    return normalized;
+}
+function clampValue(value, min, max) {
+    let current = value;
+    if (min !== undefined) {
+        current = Math.max(min, current);
+    }
+    if (max !== undefined) {
+        current = Math.min(max, current);
+    }
+    return current;
+}
+function normalizeSeed(seed, range) {
+    const l = clampValue(seed.l, range.minL, range.maxL);
+    const c = clampValue(seed.c, range.minC, range.maxC);
+    return {
+        l,
+        c: Math.max(0, c),
+        h: seed.h,
+    };
+}
+function resolveAnchorOption(option, mode) {
+    if (!option) {
+        return undefined;
+    }
+    if (typeof option === "object") {
+        return option[mode];
+    }
+    return option;
+}
+function resolveSeedNormalizeOptions(options, autoEnabled) {
+    const enabled = options?.enabled ?? autoEnabled;
+    return {
+        enabled,
+        light: { ...defaultSeedNormalize.light, ...options?.light },
+        dark: { ...defaultSeedNormalize.dark, ...options?.dark },
+    };
+}
+function resolveCandidateSteps(candidateSteps) {
+    const unique = Array.from(new Set(candidateSteps ?? defaultAutoAnchor.candidateSteps));
+    return unique.length > 0 ? unique : [9];
+}
+function resolveAutoAnchorModeOptions(base, overrides, candidateSteps) {
+    const resolvedCandidates = resolveCandidateSteps(overrides?.candidateSteps ?? candidateSteps);
+    const resolvedBackgroundStep = overrides?.backgroundStep ?? base.backgroundStep;
+    const resolvedBackgroundSteps = overrides?.backgroundSteps ?? base.backgroundSteps;
+    return {
+        candidateSteps: resolvedCandidates,
+        backgroundStep: resolvedBackgroundStep,
+        backgroundSteps: resolvedBackgroundSteps.length > 0 ? resolvedBackgroundSteps : [resolvedBackgroundStep],
+        solidStep: overrides?.solidStep ?? base.solidStep,
+        textStep: overrides?.textStep ?? base.textStep,
+        targetContrast: overrides?.targetContrast ?? base.targetContrast,
+        minBackgroundL: overrides?.minBackgroundL ?? base.minBackgroundL,
+        maxBackgroundL: overrides?.maxBackgroundL ?? base.maxBackgroundL,
+        minTextL: overrides?.minTextL ?? base.minTextL,
+        maxTextL: overrides?.maxTextL ?? base.maxTextL,
+    };
+}
+function resolveAutoAnchorOptions(options) {
+    const candidateSteps = resolveCandidateSteps(options?.candidateSteps);
+    return {
+        light: resolveAutoAnchorModeOptions(defaultAutoAnchor.light, options?.light, candidateSteps),
+        dark: resolveAutoAnchorModeOptions(defaultAutoAnchor.dark, options?.dark, candidateSteps),
+    };
+}
+function rangePenalty(value, min, max, weight = 100) {
+    if (value < min) {
+        return (min - value) * weight;
+    }
+    if (value > max) {
+        return (value - max) * weight;
+    }
+    return 0;
+}
+function scoreScale(scale, options) {
+    const solid = scale[options.solidStep];
+    const onSolid = onSolidTextTokens(solid);
+    const contrast = Math.abs(apcaContrast(onSolid.primary, solid));
+    const text = scale[options.textStep];
+    const textL = hexToOklch(text).l;
+    const backgroundLs = options.backgroundSteps.map((step) => hexToOklch(scale[step]).l);
+    const minBackgroundL = Math.min(...backgroundLs);
+    const maxBackgroundL = Math.max(...backgroundLs);
+    let score = 0;
+    const contrastDelta = options.targetContrast - contrast;
+    if (contrastDelta > 0) {
+        score += contrastDelta * 2.2;
+    }
+    score += rangePenalty(minBackgroundL, options.minBackgroundL, options.maxBackgroundL, 180);
+    score += rangePenalty(maxBackgroundL, options.minBackgroundL, options.maxBackgroundL, 180);
+    score += rangePenalty(textL, options.minTextL, options.maxTextL, 120);
+    return score;
+}
+function pickAutoAnchorStep(seed, templateId, curves, gamutStrategy, mode, options) {
+    let bestStep = 9;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const candidate of options.candidateSteps) {
+        const result = buildScaleForMode(seed, templateId, candidate, curves, gamutStrategy, mode, false);
+        const score = scoreScale(result.scale, options) + Math.abs(candidate - 9) * 2;
+        if (score < bestScore) {
+            bestScore = score;
+            bestStep = candidate;
+        }
+        else if (score === bestScore) {
+            if (Math.abs(candidate - 9) < Math.abs(bestStep - 9)) {
+                bestStep = candidate;
+            }
+        }
+    }
+    return bestStep;
+}
+function buildScaleForMode(seed, templateId, anchorStep, curves, gamutStrategy = "compress", mode = "light", includeP3 = false) {
+    const template = templates[mode][templateId];
+    const anchor = template[anchorStep];
+    const dL = seed.l - anchor.l;
+    const dC = seed.c - anchor.c;
+    const dH = seed.h - anchor.h;
+    const curveSet = resolveCurves(curves);
+    const output = {};
+    const p3Output = includeP3 ? {} : undefined;
+    let outOfGamutCount = 0;
+    let outOfP3GamutCount = 0;
+    for (const step of steps) {
+        const base = template[step];
+        const l = base.l + dL * curveSet.lightness[step];
+        const c = Math.max(0, base.c + dC * curveSet.chroma[step]);
+        const h = normalizeHue(base.h + dH);
+        const candidate = { l, c, h };
+        let current = candidate;
+        if (!inSrgbGamut(current)) {
+            outOfGamutCount += 1;
+            if (gamutStrategy === "compress") {
+                current = compressToSrgb(current);
+            }
+        }
+        output[step] = oklchToHex(current);
+        if (p3Output) {
+            let p3Current = candidate;
+            if (!inP3Gamut(p3Current)) {
+                outOfP3GamutCount += 1;
+                p3Current = compressToP3(p3Current);
+            }
+            p3Output[step] = oklchToP3(p3Current);
+        }
+    }
+    return {
+        scale: output,
+        p3: p3Output,
+        outOfGamutCount,
+        outOfP3GamutCount,
+    };
+}
+export function generateScale(options) {
+    const seedHex = getSeedHex(options.source);
+    const seedOklch = hexToOklch(seedHex);
+    const mode = options.mode ?? "both";
+    const templateId = options.template === "auto" || !options.template
+        ? selectTemplateId(seedOklch)
+        : options.template;
+    const gamutStrategy = options.gamut?.strategy ?? "compress";
+    const anchorOption = options.anchorStep ?? "auto";
+    const anchorLightOption = resolveAnchorOption(anchorOption, "light");
+    const anchorDarkOption = resolveAnchorOption(anchorOption, "dark");
+    const autoAnchorOptions = resolveAutoAnchorOptions(options.autoAnchor);
+    const autoEnabled = anchorLightOption === "auto" || anchorDarkOption === "auto";
+    const seedNormalize = resolveSeedNormalizeOptions(options.seedNormalize, autoEnabled);
+    const lightSeed = seedNormalize.enabled
+        ? normalizeSeed(seedOklch, seedNormalize.light)
+        : seedOklch;
+    const darkSeed = seedNormalize.enabled ? normalizeSeed(seedOklch, seedNormalize.dark) : seedOklch;
+    const lightAnchorStep = anchorLightOption === "auto"
+        ? pickAutoAnchorStep(lightSeed, templateId, options.curves, gamutStrategy, "light", autoAnchorOptions.light)
+        : (anchorLightOption ?? 9);
+    const darkAnchorStep = anchorDarkOption === "auto"
+        ? pickAutoAnchorStep(darkSeed, templateId, options.curves, gamutStrategy, "dark", autoAnchorOptions.dark)
+        : (anchorDarkOption ?? 9);
+    const lightResult = buildScaleForMode(lightSeed, templateId, lightAnchorStep, options.curves, gamutStrategy, "light", options.p3 ?? false);
+    const darkResult = buildScaleForMode(darkSeed, templateId, darkAnchorStep, options.curves, gamutStrategy, "dark", options.p3 ?? false);
+    const scale = {
+        light: lightResult.scale,
+        dark: darkResult.scale,
+        p3: lightResult.p3 && darkResult.p3 ? { light: lightResult.p3, dark: darkResult.p3 } : undefined,
+        meta: {
+            outOfGamutCount: lightResult.outOfGamutCount + darkResult.outOfGamutCount,
+            outOfP3GamutCount: lightResult.outOfP3GamutCount + darkResult.outOfP3GamutCount,
+            anchorSteps: {
+                light: lightAnchorStep,
+                dark: darkAnchorStep,
+            },
+        },
+    };
+    if (mode === "light") {
+        return {
+            ...scale,
+            dark: scale.light,
+            p3: scale.p3 ? { light: scale.p3.light, dark: scale.p3.light } : undefined,
+            meta: scale.meta
+                ? {
+                    ...scale.meta,
+                    anchorSteps: { light: lightAnchorStep, dark: lightAnchorStep },
+                }
+                : undefined,
+        };
+    }
+    if (mode === "dark") {
+        return {
+            ...scale,
+            light: scale.dark,
+            p3: scale.p3 ? { light: scale.p3.dark, dark: scale.p3.dark } : undefined,
+            meta: scale.meta
+                ? {
+                    ...scale.meta,
+                    anchorSteps: { light: darkAnchorStep, dark: darkAnchorStep },
+                }
+                : undefined,
+        };
+    }
+    return scale;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { generateAlphaScale } from "./alpha/generateAlphaScale.js";
+export { apcaContrast } from "./contrast/apca.js";
+export { onSolidTextTokens } from "./contrast/onSolid.js";
+export { adjustTextColor } from "./contrast/solveText.js";
+export { createTheme } from "./createTheme.js";
+export { radixSeedNames, radixSeeds } from "./data/radixSeeds.js";
+export { analyzeScale } from "./diagnostics/analyzeScale.js";
+export { analyzeTheme } from "./diagnostics/analyzeTheme.js";
+export { selectThemeColorMode } from "./exporters/selectColorMode.js";
+export { toCssVars } from "./exporters/toCssVars.js";
+export { toJson, toJsonWithMode } from "./exporters/toJson.js";
+export { toReactNative } from "./exporters/toReactNative.js";
+export { toTailwind } from "./exporters/toTailwind.js";
+export { toTs, toTsWithMode } from "./exporters/toTs.js";
+export type { AnchorStepOption, AutoAnchorModeOptions, AutoAnchorOptions, GenerateScaleOptions, SeedNormalizeOptions, SeedNormalizeRange, } from "./generateScale.js";
+export { generateScale } from "./generateScale.js";
+export type { AlphaScale, ColorHex, ColorSource, OklchColor, RadixSeedName, Scale, ScaleColorMode, ScaleDiagnostics, Step, TemplateId, Theme, ThemeColorMode, ThemeDiagnostics, } from "./types.js";

package/{src/index.ts → dist/index.js}

@@ -13,18 +13,3 @@ export { toReactNative } from "./exporters/toReactNative.js";
 export { toTailwind } from "./exporters/toTailwind.js";
 export { toTs, toTsWithMode } from "./exporters/toTs.js";
 export { generateScale } from "./generateScale.js";
-export type {
-  AlphaScale,
-  ColorHex,
-  ColorSource,
-  OklchColor,
-  RadixSeedName,
-  Scale,
-  ScaleColorMode,
-  ScaleDiagnostics,
-  Step,
-  TemplateId,
-  Theme,
-  ThemeColorMode,
-  ThemeDiagnostics,
-} from "./types.js";

package/dist/tokens/presetRadixLikeUi.d.ts

@@ -0,0 +1,5 @@
+import type { ColorHex, Scale } from "../types.js";
+export declare function buildPresetTokens(scales: Record<string, Scale>): {
+    light: Record<string, ColorHex>;
+    dark: Record<string, ColorHex>;
+};