Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import type * as Schema from "effect/Schema";
import * as Predicate from "effect/Predicate";
import "culori/css";
import { converter, parse } from "culori/fn";
export function isThemeColor(value: unknown): value is string {
return Predicate.isString(value) && toCanonicalThemeColor(value) !== null;
}
export type ThemeRgbColor = {
r: number;
g: number;
b: number;
};
type ThemeHslColor = {
h: number;
s: number;
l: number;
};
export type ThemeOklch = { L: number; C: number; h: number };
type ParsedThemeColor = { color: ThemeOklch; alpha: number };
export const THEME_LIGHT_FOREGROUND: ThemeRgbColor = { r: 255, g: 250, b: 255 };
export const THEME_DARK_FOREGROUND: ThemeRgbColor = { r: 36, g: 21, b: 35 };
export const THEME_WHITE_FOREGROUND: ThemeRgbColor = { r: 255, g: 255, b: 255 };
export const THEME_BLACK_FOREGROUND: ThemeRgbColor = { r: 0, g: 0, b: 0 };
const convertToOklch = converter("oklch");
export function parseThemeColor(value: Schema.Json | undefined): ParsedThemeColor | null {
if (!Predicate.isString(value)) return null;
const input = value.trim();
const parsed = parse(input);
if (!parsed) return null;
const color = convertToOklch(parsed);
const lightness = color.l ?? 0;
const chroma = color.c ?? 0;
const hue = color.h ?? 0;
// CSS missing components behave as zero outside interpolation. Culori omits
// a `none` alpha from its parsed object, so distinguish it from omitted alpha.
const alpha = /\/\s*none\s*\)$/i.test(input) ? 0 : (color.alpha ?? 1);
if (![lightness, chroma, hue, alpha].every(Number.isFinite)) return null;
return {
color: {
L: Math.min(1, Math.max(0, lightness)),
C: Math.max(0, chroma),
h: hue,
},
alpha: Math.min(1, Math.max(0, alpha)),
};
}
function formatThemeColorNumber(value: number, precision: number): string {
const rounded = Math.abs(value) < 10 ** -precision / 2 ? 0 : value;
return rounded.toFixed(precision).replace(/(?:\.0+|(?:(\.[0-9]*?)0+))$/, "$1");
}
export function formatOklchThemeColor(color: ThemeOklch, alpha = 1): string {
const normalizedHue = color.C < 0.0000005 ? 0 : ((color.h % 360) + 360) % 360;
const body = `${formatThemeColorNumber(color.L, 6)} ${formatThemeColorNumber(color.C, 6)} ${formatThemeColorNumber(normalizedHue, 3)}`;
return alpha < 1 ? `oklch(${body} / ${formatThemeColorNumber(alpha, 4)})` : `oklch(${body})`;
}
/**
* Decode a literal CSS color into the runtime's canonical OKLCH form. Stored
* values use this path in memory without mutating localStorage.
*/
export function toCanonicalThemeColor(value: Schema.Json | undefined): string | null {
const parsed = parseThemeColor(value);
return parsed ? formatOklchThemeColor(parsed.color, parsed.alpha) : null;
}
/** Convert a runtime theme color for hex-only editor and import adapters. */
export function themeColorToHex(value: string): string | null {
const color = parseThemeColor(value);
const parsed = color ? { rgb: themeOklchToRgb(color.color), alpha: color.alpha } : null;
if (!parsed) return null;
const opaque = themeRgbToHexColor(parsed.rgb);
if (parsed.alpha >= 1) return opaque;
const alpha = Math.round(parsed.alpha * 255)
.toString(16)
.padStart(2, "0");
return `${opaque}${alpha}`;
}
export function parseThemeRgbColor(value: string, fallback: ThemeRgbColor): ThemeRgbColor {
const parsed = parseThemeColor(value);
return parsed ? themeOklchToRgb(parsed.color) : fallback;
}
function themeRgbToHexColor(color: ThemeRgbColor): string {
return `#${[color.r, color.g, color.b]
.map((channel) =>
Math.round(Math.min(255, Math.max(0, channel)))
.toString(16)
.padStart(2, "0"),
)
.join("")}`;
}
export function themeRgbToThemeColor(color: ThemeRgbColor): string {
return formatOklchThemeColor(themeRgbToOklch(color));
}
export function themeRgbToHsl(color: ThemeRgbColor): ThemeHslColor {
const red = color.r / 255;
const green = color.g / 255;
const blue = color.b / 255;
const max = Math.max(red, green, blue);
const min = Math.min(red, green, blue);
const delta = max - min;
const lightness = (max + min) / 2;
if (delta === 0) return { h: 0, s: 0, l: lightness };
const saturation = delta / (1 - Math.abs(2 * lightness - 1));
let hue = 0;
if (max === red) hue = ((green - blue) / delta) % 6;
else if (max === green) hue = (blue - red) / delta + 2;
else hue = (red - green) / delta + 4;
return { h: (hue * 60 + 360) % 360, s: saturation, l: lightness };
}
export function themeHslToRgb(color: ThemeHslColor): ThemeRgbColor {
const hue = ((color.h % 360) + 360) % 360;
const chroma = (1 - Math.abs(2 * color.l - 1)) * color.s;
const hueSector = hue / 60;
const secondary = chroma * (1 - Math.abs((hueSector % 2) - 1));
const match = color.l - chroma / 2;
const [red, green, blue] =
hueSector < 1
? [chroma, secondary, 0]
: hueSector < 2
? [secondary, chroma, 0]
: hueSector < 3
? [0, chroma, secondary]
: hueSector < 4
? [0, secondary, chroma]
: hueSector < 5
? [secondary, 0, chroma]
: [chroma, 0, secondary];
return { r: (red + match) * 255, g: (green + match) * 255, b: (blue + match) * 255 };
}
export function mixThemeRgbColors(
base: ThemeRgbColor,
overlay: ThemeRgbColor,
amount: number,
): ThemeRgbColor {
return {
r: base.r + (overlay.r - base.r) * amount,
g: base.g + (overlay.g - base.g) * amount,
b: base.b + (overlay.b - base.b) * amount,
};
}
export function themeRelativeLuminance(color: ThemeRgbColor): number {
const linearize = (channel: number) => {
const normalized = channel / 255;
return normalized <= 0.03928 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
};
return 0.2126 * linearize(color.r) + 0.7152 * linearize(color.g) + 0.0722 * linearize(color.b);
}
// ---------------------------------------------------------------------------
// Vivid palette engine: perceptual (OKLCH) derivation for user-created themes.
function srgbChannelToLinear(channel: number): number {
const c = channel / 255;
return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
}
function linearChannelToSrgb(channel: number): number {
const c = channel <= 0.0031308 ? channel * 12.92 : 1.055 * channel ** (1 / 2.4) - 0.055;
return Math.round(Math.min(1, Math.max(0, c)) * 255);
}
export function themeRgbToOklch(color: ThemeRgbColor): ThemeOklch {
const r = srgbChannelToLinear(color.r);
const g = srgbChannelToLinear(color.g);
const b = srgbChannelToLinear(color.b);
const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
const a = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;
const bb = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;
return { L, C: Math.hypot(a, bb), h: (Math.atan2(bb, a) * 180) / Math.PI };
}
function oklchToRgbUnclamped({ L, C, h }: ThemeOklch) {
const hr = (h * Math.PI) / 180;
const a = C * Math.cos(hr);
const bb = C * Math.sin(hr);
const l = (L + 0.3963377774 * a + 0.2158037573 * bb) ** 3;
const m = (L - 0.1055613458 * a - 0.0638541728 * bb) ** 3;
const s = (L - 0.0894841775 * a - 1.291485548 * bb) ** 3;
return {
r: 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
g: -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
b: -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
};
}
/** Find the greatest chroma along the same lightness and hue that fits in sRGB. */
function mapThemeOklchToSrgbGamut(color: ThemeOklch): ThemeOklch {
const isInGamut = (C: number) => {
const linear = oklchToRgbUnclamped({ ...color, C });
return [linear.r, linear.g, linear.b].every(
(channel) => channel >= -0.0001 && channel <= 1.0001,
);
};
if (isInGamut(color.C)) return color;
let low = 0;
let high = color.C;
const chromaResolution = 0.000001;
const steps = Math.max(
1,
Math.ceil(Math.log2(Math.max(color.C, chromaResolution)) - Math.log2(chromaResolution)),
);
for (let step = 0; step < steps; step += 1) {
const mid = (low + high) / 2;
if (isInGamut(mid)) low = mid;
else high = mid;
}
return { ...color, C: low };
}
/** Convert to sRGB after applying the palette engine's gamut mapping. */
export function themeOklchToRgb(color: ThemeOklch): ThemeRgbColor {
const linear = oklchToRgbUnclamped(mapThemeOklchToSrgbGamut(color));
return {
r: linearChannelToSrgb(linear.r),
g: linearChannelToSrgb(linear.g),
b: linearChannelToSrgb(linear.b),
};
}
export function themeOklchToThemeColor(color: ThemeOklch): string {
return formatOklchThemeColor(mapThemeOklchToSrgbGamut(color));
}
/** Binary-search the lightness that reaches the contrast target against a background. */
export function solveOklchLightness(
base: ThemeOklch,
against: ThemeRgbColor,
minContrast: number,
direction: "lighter" | "darker",
): ThemeOklch {
let low = direction === "lighter" ? base.L : 0;
let high = direction === "lighter" ? 1 : base.L;
let candidate = { ...base };
if (themeContrastRatio(themeOklchToRgb(candidate), against) >= minContrast) return candidate;
for (let step = 0; step < 18; step += 1) {
const mid = (low + high) / 2;
candidate = { ...base, L: mid };
const contrast = themeContrastRatio(themeOklchToRgb(candidate), against);
if (contrast >= minContrast) {
if (direction === "lighter") high = mid;
else low = mid;
} else {
if (direction === "lighter") low = mid;
else high = mid;
}
}
return { ...base, L: direction === "lighter" ? high : low };
}
export function themeContrastRatio(first: ThemeRgbColor, second: ThemeRgbColor): number {
const firstLuminance = themeRelativeLuminance(first);
const secondLuminance = themeRelativeLuminance(second);
const lighter = Math.max(firstLuminance, secondLuminance);
const darker = Math.min(firstLuminance, secondLuminance);
return (lighter + 0.05) / (darker + 0.05);
}