Open History to see the last commit
1import {
2 MousePointer2Icon,
3 PaintbrushIcon,
4 PlusIcon,
5 XIcon,
6 ChevronDownIcon,
7 ChevronUpIcon,
8} from "lucide-react";
9import { useEffect, useRef, useState, type PointerEvent as ReactPointerEvent } from "react";
10import {
11 applyThemeColorPreview,
12 THEME_COLOR_ROLES,
13 THEME_FILE_VERSION,
14 createVividThemeColors,
15 getCustomThemes,
16 getStandardThemeColors,
17 getThemeColorsForMode,
18 getThemeModes,
19 installCustomTheme,
20 isThemeColor,
21 parseThemeFile,
22 removeCustomTheme,
23 themeIdFromName,
24 updateThemeColorFamily,
25 updateCustomTheme,
26 type ThemeAppearance,
27 type ThemeColors,
28 type ThemeColorRole,
29 type ThemeDefinition,
30} from "../../themePalette";
31import { useViewportSize } from "../../hooks/useViewportSize";
32import { cn } from "../../lib/utils";
33import { Button } from "../ui/button";
34import { Input } from "../ui/input";
35import { Switch } from "../ui/switch";
36import { Toggle, ToggleGroup } from "../ui/toggle-group";
37import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
38import { getThemeRoleLabel, ThemeColorField } from "./ThemeColorPicker";
39import {
40 clearThemeInspectorHover,
41 clearThemeInspectorHighlights,
42 highlightThemeRoleUsage,
43 inspectThemeRoleAtElement,
44 inspectThemeRoleFromUtilitiesAtElement,
45 refreshThemeInspectorSpotlight,
46 showThemeInspectorHover,
47 type ThemeElementInspection,
48} from "./themeInspector";
49
50const THEME_EDITOR_SIMPLE_ROLES: ReadonlyArray<ThemeColorRole> = ["canvas", "accent"];
51
52type ThemeEditorColorFamily = Readonly<{
53 id: string;
54 label: string;
55 role: ThemeColorRole;
56 roles: ReadonlyArray<ThemeColorRole>;
57}>;
58
59const THEME_EDITOR_ROLE_GROUPS: ReadonlyArray<{
60 id: string;
61 title: string;
62 families: ReadonlyArray<ThemeEditorColorFamily>;
63}> = [
64 {
65 id: "foundation",
66 title: "Foundation",
67 families: [
68 {
69 id: "background",
70 label: "Background",
71 role: "canvas",
72 roles: ["canvas", "chrome", "toolbar"],
73 },
74 { id: "surface", label: "Surface", role: "surface", roles: ["surface"] },
75 {
76 id: "raised-surface",
77 label: "Raised surface",
78 role: "surfaceRaised",
79 roles: ["surfaceRaised"],
80 },
81 {
82 id: "overlay",
83 label: "Overlay",
84 role: "surfaceOverlay",
85 roles: ["surfaceOverlay"],
86 },
87 {
88 id: "text",
89 label: "Text",
90 role: "text",
91 roles: ["text", "toolbarForeground", "toolbarControlForeground"],
92 },
93 {
94 id: "muted-text",
95 label: "Muted text",
96 role: "mutedForeground",
97 roles: [
98 "textMuted",
99 "mutedForeground",
100 "placeholder",
101 "secondaryLabel",
102 "iconMuted",
103 "sidebarMutedForeground",
104 ],
105 },
106 {
107 id: "border",
108 label: "Border",
109 role: "border",
110 roles: ["border", "toolbarBorder", "sidebarBorder"],
111 },
112 { id: "input", label: "Input", role: "input", roles: ["input"] },
113 ],
114 },
115 {
116 id: "brand-content",
117 title: "Brand & content",
118 families: [
119 {
120 id: "subtle-surface",
121 label: "Subtle surface",
122 role: "secondary",
123 roles: ["secondary", "secondaryForeground", "muted", "toolbarControl"],
124 },
125 {
126 id: "highlight-surface",
127 label: "Highlight surface",
128 role: "accentSurface",
129 roles: ["accentSurface", "accentSurfaceForeground", "toolbarControlHover"],
130 },
131 {
132 id: "accent",
133 label: "Accent",
134 role: "accent",
135 roles: [
136 "accent",
137 "accentForeground",
138 "focus",
139 "update",
140 "updateForeground",
141 "updateSurface",
142 "terminalCursor",
143 ],
144 },
145 {
146 id: "action",
147 label: "Action",
148 role: "messageAction",
149 roles: ["messageAction", "messageActionForeground", "messageActionHover"],
150 },
151 {
152 id: "message-surface",
153 label: "Message surface",
154 role: "messageSurface",
155 roles: ["messageSurface", "messageForeground"],
156 },
157 {
158 id: "code-surface",
159 label: "Code surface",
160 role: "codeBackground",
161 roles: ["codeBackground", "codeForeground"],
162 },
163 ],
164 },
165 {
166 id: "search",
167 title: "Search",
168 families: [
169 {
170 id: "search-matches",
171 label: "Search matches",
172 role: "searchMatchBackground",
173 roles: ["searchMatchBackground", "searchMatchForeground"],
174 },
175 {
176 id: "current-match",
177 label: "Current match",
178 role: "searchMatchActiveBackground",
179 roles: ["searchMatchActiveBackground", "searchMatchActiveForeground"],
180 },
181 ],
182 },
183 {
184 id: "context",
185 title: "Context",
186 families: [
187 {
188 id: "sidebar-background",
189 label: "Sidebar background",
190 role: "sidebar",
191 roles: ["sidebar", "sidebarForeground"],
192 },
193 {
194 id: "sidebar-controls",
195 label: "Sidebar controls",
196 role: "sidebarControlSurface",
197 roles: ["sidebarControlSurface"],
198 },
199 {
200 id: "sidebar-selection",
201 label: "Sidebar selection",
202 role: "sidebarRowSelected",
203 roles: ["sidebarRowHover", "sidebarRowActive", "sidebarRowSelected"],
204 },
205 {
206 id: "terminal-background",
207 label: "Terminal background",
208 role: "terminalBackground",
209 roles: [
210 "terminalBackground",
211 "terminalForeground",
212 "terminalSelection",
213 "terminalScrollbar",
214 "terminalScrollbarHover",
215 ],
216 },
217 ],
218 },
219 {
220 id: "status",
221 title: "Status",
222 families: [
223 {
224 id: "error",
225 label: "Error",
226 role: "error",
227 roles: ["error", "errorForeground", "errorSurface"],
228 },
229 {
230 id: "warning",
231 label: "Warning",
232 role: "warning",
233 roles: ["warning", "warningForeground", "warningSurface"],
234 },
235 ],
236 },
237];
238
239const THEME_EDITOR_COLOR_FAMILIES = THEME_EDITOR_ROLE_GROUPS.flatMap((group) => group.families);
240const THEME_EDITOR_COLOR_FAMILY_BY_ROLE = new Map(
241 THEME_EDITOR_COLOR_FAMILIES.flatMap((family) =>
242 family.roles.map((role) => [role, family] as const),
243 ),
244);
245
246function getThemeEditorColorFamily(role: ThemeColorRole): ThemeEditorColorFamily | null {
247 return THEME_EDITOR_COLOR_FAMILY_BY_ROLE.get(role) ?? null;
248}
249
250type ThemeEditorColors = ThemeColors;
251type ThemeEditorColorsByAppearance = Record<ThemeAppearance, ThemeEditorColors>;
252
253function getThemeEditorDefaults(appearance: ThemeAppearance): ThemeEditorColors {
254 return { ...getStandardThemeColors(appearance) };
255}
256
257function getThemeEditorColorsByAppearance(): ThemeEditorColorsByAppearance {
258 return {
259 light: getThemeEditorDefaults("light"),
260 dark: getThemeEditorDefaults("dark"),
261 };
262}
263
264function isThemeEditorColor(value: string): boolean {
265 return isThemeColor(value.trim());
266}
267
268function getManagedEditorColors(
269 appearance: ThemeAppearance,
270 colors: ThemeEditorColors,
271): ThemeEditorColors {
272 const defaults = getStandardThemeColors(appearance);
273 return createVividThemeColors(
274 appearance,
275 isThemeEditorColor(colors.canvas) ? colors.canvas : defaults.canvas,
276 isThemeEditorColor(colors.accent) ? colors.accent : defaults.accent,
277 );
278}
279
280const PANEL_MARGIN = 8;
281const PANEL_MIN_WIDTH = 280;
282const PANEL_MIN_HEIGHT = 220;
283
284/** Keeps the panel horizontally inside the viewport. Vertically only its header must stay
285 * visible, so users can park the panel low to see the app behind it. */
286function clampPanelPosition(
287 viewport: { readonly width: number; readonly height: number },
288 x: number,
289 y: number,
290 width: number,
291) {
292 const maxX = Math.max(PANEL_MARGIN, viewport.width - width - PANEL_MARGIN);
293 const maxY = Math.max(PANEL_MARGIN, viewport.height - 48);
294 return {
295 x: Math.min(Math.max(x, PANEL_MARGIN), maxX),
296 y: Math.min(Math.max(y, PANEL_MARGIN), maxY),
297 };
298}
299
300const readWindowViewport = () => ({ width: window.innerWidth, height: window.innerHeight });
301
302// Kept out of the component: the compiler cannot lower a throw inside try/catch.
303function retireMergedTheme(retired: ThemeDefinition, mergeTarget: ThemeDefinition) {
304 try {
305 removeCustomTheme(retired.id);
306 } catch (cause) {
307 // Restore the pre-merge target on retirement failure; leaving the persisted merge would collide on retry.
308 try {
309 updateCustomTheme(mergeTarget);
310 } catch {}
311 throw cause;
312 }
313}
314
315export function ThemeEditorPanel({
316 open,
317 onOpenChange,
318 onSaved,
319 editingTheme,
320 initialAppearance,
321 seedTheme,
322 seedName,
323 restoreTheme,
324}: {
325 open: boolean;
326 onOpenChange: (open: boolean) => void;
327 onSaved: (
328 theme: ThemeDefinition,
329 context: {
330 created: boolean;
331 mergedAppearance?: ThemeAppearance;
332 },
333 ) => boolean;
334 editingTheme: ThemeDefinition | null;
335 initialAppearance: ThemeAppearance;
336 seedTheme?: ThemeDefinition | null;
337 seedName?: string | undefined;
338 restoreTheme: () => void;
339}) {
340 const isEditing = editingTheme !== null;
341 const [name, setName] = useState("");
342 const [activeAppearance, setActiveAppearance] = useState<ThemeAppearance>(initialAppearance);
343 const [isAdvanced, setIsAdvanced] = useState(false);
344 const [colorsByAppearance, setColorsByAppearance] = useState<ThemeEditorColorsByAppearance>(() =>
345 getThemeEditorColorsByAppearance(),
346 );
347 const [simpleColorsDirtyByAppearance, setSimpleColorsDirtyByAppearance] = useState<
348 Record<ThemeAppearance, boolean>
349 >({ light: false, dark: false });
350 const [shouldRegenerateGuidedColors, setShouldRegenerateGuidedColors] = useState(false);
351 const [error, setError] = useState<string | null>(null);
352 const [isMinimized, setIsMinimized] = useState(false);
353 const [roleQuery, setRoleQuery] = useState("");
354 const [isInspecting, setIsInspecting] = useState(false);
355 const [selectedRole, setSelectedRole] = useState<ThemeColorRole | null>(null);
356 const [usageCount, setUsageCount] = useState<number | null>(null);
357 // The rendered width is CSS-sized unless the user resized the panel, so the position
358 // remembers the width measured at the last drag or resize.
359 const [position, setPosition] = useState<{ x: number; y: number; width: number } | null>(null);
360 const [size, setSize] = useState<{ width: number; height: number } | null>(null);
361 const panelRef = useRef<HTMLDivElement>(null);
362 const colorEditSnapshotRef = useRef<{
363 colorsByAppearance: ThemeEditorColorsByAppearance;
364 simpleColorsDirtyByAppearance: Record<ThemeAppearance, boolean>;
365 shouldRegenerateGuidedColors: boolean;
366 } | null>(null);
367 const dragOffsetRef = useRef<{ dx: number; dy: number; width: number } | null>(null);
368 const resizeStartRef = useRef<{
369 pointerX: number;
370 pointerY: number;
371 left: number;
372 top: number;
373 width: number;
374 height: number;
375 } | null>(null);
376 // Seed during render so the first open frame cannot preview the previous session's colors.
377 const [seededOpen, setSeededOpen] = useState(false);
378 if (seededOpen !== open) {
379 setSeededOpen(open);
380 if (open) {
381 const sourceTheme = editingTheme ?? seedTheme ?? null;
382 const nextColors = getThemeEditorColorsByAppearance();
383 const nextAppearance = sourceTheme
384 ? getThemeColorsForMode(sourceTheme, initialAppearance)
385 ? initialAppearance
386 : sourceTheme.appearance
387 : initialAppearance;
388 if (sourceTheme) {
389 nextColors[sourceTheme.appearance] = { ...sourceTheme.colors };
390 for (const appearance of ["light", "dark"] as const) {
391 const variantColors = sourceTheme.variants?.[appearance];
392 if (variantColors) nextColors[appearance] = { ...variantColors };
393 }
394 }
395
396 setName(editingTheme?.label ?? seedName ?? "");
397 setActiveAppearance(nextAppearance);
398 // Open unmanaged themes in advanced mode to preserve imported or hand-tuned colors.
399 setIsAdvanced(sourceTheme !== null && sourceTheme.managed !== true);
400 setSimpleColorsDirtyByAppearance({ light: false, dark: false });
401 setShouldRegenerateGuidedColors(sourceTheme !== null && sourceTheme.managed !== true);
402 setColorsByAppearance(nextColors);
403 setSelectedRole(null);
404 setUsageCount(null);
405 setIsInspecting(false);
406 setError(null);
407 }
408 }
409
410 const nameTargetId = themeIdFromName(name);
411 const normalizedName = name.trim().toLowerCase();
412 const mergeTarget =
413 normalizedName === ""
414 ? null
415 : (getCustomThemes().find(
416 (theme) =>
417 theme.id !== editingTheme?.id &&
418 (theme.id === nameTargetId || theme.label.trim().toLowerCase() === normalizedName),
419 ) ?? null);
420 const takenAppearances = mergeTarget ? getThemeModes(mergeTarget) : [];
421 const editableAppearances = editingTheme ? getThemeModes(editingTheme) : null;
422
423 const appearanceLockReason = (appearance: ThemeAppearance): string | null => {
424 if (editableAppearances && !editableAppearances.includes(appearance)) {
425 return `“${editingTheme?.label}” has no ${appearance} palette. Create a theme with the same name to add one.`;
426 }
427 if (!isEditing && takenAppearances.includes(appearance)) {
428 return `“${mergeTarget?.label}” already has a ${appearance} palette.`;
429 }
430 return null;
431 };
432
433 const mergeKey =
434 isEditing || mergeTarget === null ? null : `${mergeTarget.id}:${takenAppearances.join(",")}`;
435 const [appliedMergeKey, setAppliedMergeKey] = useState<string | null>(null);
436 if (appliedMergeKey !== mergeKey) {
437 setAppliedMergeKey(mergeKey);
438 if (
439 mergeKey !== null &&
440 takenAppearances.length === 1 &&
441 takenAppearances.includes(activeAppearance)
442 ) {
443 setActiveAppearance(takenAppearances[0] === "light" ? "dark" : "light");
444 }
445 }
446
447 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- applies the edited colors to the document as a live theme preview while the editor is open
448 useEffect(() => {
449 if (!open) return;
450 applyThemeColorPreview(colorsByAppearance[activeAppearance], activeAppearance);
451 }, [activeAppearance, colorsByAppearance, open]);
452
453 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- restores the document theme when the editor closes or unmounts
454 useEffect(() => {
455 if (!open) return;
456 return () => {
457 restoreTheme();
458 };
459 }, [open, restoreTheme]);
460
461 const updateColor = (role: ThemeColorRole, value: string) => {
462 setColorsByAppearance((current) => {
463 const nextColors = { ...current[activeAppearance], [role]: value };
464 const shouldManageColors =
465 !isAdvanced && THEME_EDITOR_SIMPLE_ROLES.includes(role) && isThemeEditorColor(value);
466
467 return {
468 ...current,
469 [activeAppearance]: isAdvanced
470 ? updateThemeColorFamily(activeAppearance, current[activeAppearance], role, value)
471 : shouldManageColors
472 ? getManagedEditorColors(activeAppearance, nextColors)
473 : nextColors,
474 };
475 });
476 if (!isAdvanced && THEME_EDITOR_SIMPLE_ROLES.includes(role) && isThemeEditorColor(value)) {
477 setSimpleColorsDirtyByAppearance((current) => ({
478 ...current,
479 [activeAppearance]: true,
480 }));
481 }
482 if (isAdvanced) setShouldRegenerateGuidedColors(true);
483 };
484
485 // A color edit also rewrites derived roles, so cancelling restores the whole snapshot rather than
486 // replaying the previous value through updateColor.
487 const startColorEdit = () => {
488 colorEditSnapshotRef.current = {
489 colorsByAppearance,
490 simpleColorsDirtyByAppearance,
491 shouldRegenerateGuidedColors,
492 };
493 };
494
495 const cancelColorEdit = () => {
496 const snapshot = colorEditSnapshotRef.current;
497 colorEditSnapshotRef.current = null;
498 if (!snapshot) return;
499 setColorsByAppearance(snapshot.colorsByAppearance);
500 setSimpleColorsDirtyByAppearance(snapshot.simpleColorsDirtyByAppearance);
501 setShouldRegenerateGuidedColors(snapshot.shouldRegenerateGuidedColors);
502 };
503
504 const selectThemeRole = (role: ThemeColorRole, reveal = false) => {
505 const visibleRole = getThemeEditorColorFamily(role)?.role ?? role;
506 setSelectedRole(visibleRole);
507 if (!THEME_EDITOR_SIMPLE_ROLES.includes(visibleRole)) {
508 setIsAdvanced(true);
509 setRoleQuery("");
510 }
511 if (!reveal) return;
512
513 requestAnimationFrame(() => {
514 panelRef.current?.querySelector(`[data-theme-color-role="${visibleRole}"]`)?.scrollIntoView({
515 behavior: window.matchMedia("(prefers-reduced-motion: reduce)").matches ? "auto" : "smooth",
516 block: "nearest",
517 });
518 });
519 };
520
521 const toggleThemeRole = (role: ThemeColorRole) => {
522 setSelectedRole((current) => (current === role ? null : role));
523 };
524
525 const clearInspectorSelection = () => {
526 setSelectedRole(null);
527 setUsageCount(null);
528 setIsInspecting(false);
529 };
530
531 const selectedHighlightRoles = selectedRole
532 ? isAdvanced
533 ? (getThemeEditorColorFamily(selectedRole)?.roles ?? [selectedRole])
534 : THEME_EDITOR_SIMPLE_ROLES.includes(selectedRole)
535 ? THEME_COLOR_ROLES.filter(
536 (role) =>
537 colorsByAppearance[activeAppearance][role].trim().toLowerCase() ===
538 colorsByAppearance[activeAppearance][selectedRole].trim().toLowerCase(),
539 )
540 : [selectedRole]
541 : [];
542 const selectedHighlightRolesKey = selectedHighlightRoles.join(",");
543
544 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- highlights role usage in the DOM, refreshed by a MutationObserver and resize and scroll listeners
545 useEffect(() => {
546 clearThemeInspectorHighlights();
547 if (!open || selectedRole === null || isInspecting) return;
548
549 const highlightedRoles = selectedHighlightRolesKey.split(",") as Array<ThemeColorRole>;
550 const refreshHighlights = () => setUsageCount(highlightThemeRoleUsage(highlightedRoles));
551 refreshHighlights();
552 // Each refresh snapshots the whole tree twice; throttle streaming and virtualization mutations.
553 const MIN_REFRESH_INTERVAL_MS = 500;
554 let refreshFrame: number | null = null;
555 let refreshTimer: ReturnType<typeof setTimeout> | null = null;
556 let lastRefreshAt = performance.now();
557 const scheduleRefresh = () => {
558 if (refreshFrame !== null || refreshTimer !== null) return;
559 const wait = Math.max(0, MIN_REFRESH_INTERVAL_MS - (performance.now() - lastRefreshAt));
560 const run = () => {
561 refreshFrame = null;
562 refreshTimer = null;
563 lastRefreshAt = performance.now();
564 refreshHighlights();
565 };
566 if (wait === 0) refreshFrame = requestAnimationFrame(run);
567 else refreshTimer = setTimeout(run, wait);
568 };
569 const observer = new MutationObserver((mutations) => {
570 if (
571 mutations.every(
572 (mutation) =>
573 mutation.target instanceof Element &&
574 (mutation.target.closest("#theme-inspector-spotlight") ||
575 mutation.target.closest("[data-theme-editor-panel]")),
576 )
577 ) {
578 return;
579 }
580 scheduleRefresh();
581 });
582 observer.observe(document.body, { childList: true, subtree: true });
583 let spotlightFrame: number | null = null;
584 const scheduleSpotlightRefresh = () => {
585 if (spotlightFrame !== null) return;
586 spotlightFrame = requestAnimationFrame(() => {
587 spotlightFrame = null;
588 refreshThemeInspectorSpotlight();
589 });
590 };
591 window.addEventListener("resize", scheduleSpotlightRefresh);
592 window.addEventListener("scroll", scheduleSpotlightRefresh, true);
593 return () => {
594 observer.disconnect();
595 if (refreshFrame !== null) cancelAnimationFrame(refreshFrame);
596 if (refreshTimer !== null) clearTimeout(refreshTimer);
597 if (spotlightFrame !== null) cancelAnimationFrame(spotlightFrame);
598 window.removeEventListener("resize", scheduleSpotlightRefresh);
599 window.removeEventListener("scroll", scheduleSpotlightRefresh, true);
600 clearThemeInspectorHighlights();
601 setUsageCount(null);
602 };
603 }, [isInspecting, open, selectedHighlightRolesKey, selectedRole]);
604
605 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- document pointer, click and key listeners that drive the inspect-mode hover overlay
606 useEffect(() => {
607 if (!open || !isInspecting) {
608 clearThemeInspectorHover();
609 return;
610 }
611
612 let shouldDisarmAfterClick = false;
613 let hoverTarget: Element | null = null;
614 let hoverInspection: ThemeElementInspection | null = null;
615 let hoverTimer: number | null = null;
616 let hoverFrame: number | null = null;
617 const clearHoverTimer = () => {
618 if (hoverTimer === null) return;
619 window.clearTimeout(hoverTimer);
620 hoverTimer = null;
621 };
622 const clearHover = () => {
623 clearHoverTimer();
624 hoverTarget = null;
625 hoverInspection = null;
626 clearThemeInspectorHover();
627 };
628 const showInspection = (inspection: ThemeElementInspection) => {
629 hoverInspection = inspection;
630 showThemeInspectorHover(
631 inspection,
632 getThemeEditorColorFamily(inspection.role)?.label ?? getThemeRoleLabel(inspection.role),
633 );
634 };
635 const handlePointerOver = (event: PointerEvent) => {
636 const target = event.target;
637 if (!(target instanceof Element) || target.closest("[data-theme-editor-panel]")) {
638 clearHover();
639 return;
640 }
641
642 clearHoverTimer();
643 hoverTarget = target;
644 hoverInspection = null;
645 const utilityInspection = inspectThemeRoleFromUtilitiesAtElement(target);
646 if (utilityInspection) {
647 showInspection(utilityInspection);
648 return;
649 }
650
651 clearThemeInspectorHover();
652 hoverTimer = window.setTimeout(() => {
653 hoverTimer = null;
654 if (hoverTarget !== target || !target.isConnected) return;
655 const inspection = inspectThemeRoleAtElement(target);
656 if (inspection) showInspection(inspection);
657 }, 140);
658 };
659 const handlePointerOut = (event: PointerEvent) => {
660 if (event.relatedTarget === null) clearHover();
661 };
662 const handlePointerDown = (event: PointerEvent) => {
663 const target = event.target;
664 if (!(target instanceof Element) || target.closest("[data-theme-editor-panel]")) return;
665 event.preventDefault();
666 event.stopPropagation();
667 clearHoverTimer();
668 const inspection =
669 hoverTarget === target && hoverInspection
670 ? hoverInspection
671 : inspectThemeRoleAtElement(target);
672 if (!inspection) return;
673 clearHover();
674 selectThemeRole(inspection.role, true);
675 shouldDisarmAfterClick = true;
676 };
677 const blockInspectedClick = (event: MouseEvent) => {
678 const target = event.target;
679 if (!(target instanceof Element) || target.closest("[data-theme-editor-panel]")) return;
680 event.preventDefault();
681 event.stopPropagation();
682 if (shouldDisarmAfterClick) setIsInspecting(false);
683 shouldDisarmAfterClick = false;
684 };
685 const cancelInspection = (event: KeyboardEvent) => {
686 if (event.key !== "Escape") return;
687 event.preventDefault();
688 clearHover();
689 clearInspectorSelection();
690 };
691 const refreshHover = () => {
692 if (!hoverInspection || hoverFrame !== null) return;
693 hoverFrame = requestAnimationFrame(() => {
694 hoverFrame = null;
695 if (hoverInspection) {
696 showThemeInspectorHover(
697 hoverInspection,
698 getThemeEditorColorFamily(hoverInspection.role)?.label ??
699 getThemeRoleLabel(hoverInspection.role),
700 );
701 }
702 });
703 };
704 const clearHoverOnScroll = () => clearHover();
705
706 document.addEventListener("pointerover", handlePointerOver, true);
707 document.addEventListener("pointerout", handlePointerOut, true);
708 document.addEventListener("pointerdown", handlePointerDown, true);
709 document.addEventListener("click", blockInspectedClick, true);
710 document.addEventListener("keydown", cancelInspection, true);
711 window.addEventListener("resize", refreshHover);
712 window.addEventListener("scroll", clearHoverOnScroll, true);
713 return () => {
714 document.removeEventListener("pointerover", handlePointerOver, true);
715 document.removeEventListener("pointerout", handlePointerOut, true);
716 document.removeEventListener("pointerdown", handlePointerDown, true);
717 document.removeEventListener("click", blockInspectedClick, true);
718 document.removeEventListener("keydown", cancelInspection, true);
719 window.removeEventListener("resize", refreshHover);
720 window.removeEventListener("scroll", clearHoverOnScroll, true);
721 clearHoverTimer();
722 if (hoverFrame !== null) cancelAnimationFrame(hoverFrame);
723 clearThemeInspectorHover();
724 };
725 }, [clearInspectorSelection, isInspecting, open, selectThemeRole]);
726
727 const handleAdvancedChange = (checked: boolean) => {
728 setIsAdvanced(checked);
729 if (checked) return;
730 if (selectedRole && !THEME_EDITOR_SIMPLE_ROLES.includes(selectedRole)) {
731 setSelectedRole(null);
732 }
733 if (!shouldRegenerateGuidedColors) return;
734
735 const managedAppearances: ReadonlyArray<ThemeAppearance> =
736 editingTheme && getThemeModes(editingTheme).length > 1
737 ? ["light", "dark"]
738 : [activeAppearance];
739 setSimpleColorsDirtyByAppearance((current) => {
740 const next = { ...current };
741 for (const appearance of managedAppearances) next[appearance] = true;
742 return next;
743 });
744 setColorsByAppearance((current) => {
745 const next = { ...current };
746 for (const appearance of managedAppearances) {
747 next[appearance] = getManagedEditorColors(appearance, current[appearance]);
748 }
749 return next;
750 });
751 setShouldRegenerateGuidedColors(false);
752 };
753
754 const handleSubmit = () => {
755 if (!name.trim()) {
756 setError("Name your theme first.");
757 return;
758 }
759
760 try {
761 const colorsForSave = !isAdvanced
762 ? {
763 light: simpleColorsDirtyByAppearance.light
764 ? getManagedEditorColors("light", colorsByAppearance.light)
765 : colorsByAppearance.light,
766 dark: simpleColorsDirtyByAppearance.dark
767 ? getManagedEditorColors("dark", colorsByAppearance.dark)
768 : colorsByAppearance.dark,
769 }
770 : colorsByAppearance;
771
772 let savedTheme: ThemeDefinition;
773 let mergedAppearance: ThemeAppearance | null = null;
774 let retiredTheme: ThemeDefinition | null = null;
775 if (editingTheme && mergeTarget) {
776 const editedModes = getThemeModes(editingTheme);
777 const collision = editedModes.find((mode) => takenAppearances.includes(mode));
778 if (collision) {
779 setError(`“${mergeTarget.label}” already has a ${collision} palette. Pick another name.`);
780 return;
781 }
782 mergedAppearance = editedModes[0] ?? null;
783 savedTheme = updateCustomTheme({
784 ...parseThemeFile({
785 version: THEME_FILE_VERSION,
786 id: mergeTarget.id,
787 name: mergeTarget.label,
788 appearance: mergeTarget.appearance,
789 colors: mergeTarget.colors,
790 variants: {
791 ...mergeTarget.variants,
792 ...Object.fromEntries(editedModes.map((mode) => [mode, colorsForSave[mode]])),
793 },
794 ...(mergeTarget.managed === true && !isAdvanced ? { managed: true } : {}),
795 }),
796 ...(mergeTarget.collection ? { collection: mergeTarget.collection } : {}),
797 });
798 retiredTheme = editingTheme;
799 retireMergedTheme(editingTheme, mergeTarget);
800 } else if (editingTheme) {
801 const baseAppearance = editingTheme.appearance;
802 const variantAppearance = baseAppearance === "light" ? "dark" : "light";
803 savedTheme = updateCustomTheme({
804 ...parseThemeFile({
805 version: THEME_FILE_VERSION,
806 id: editingTheme.id,
807 name,
808 appearance: baseAppearance,
809 colors: colorsForSave[baseAppearance],
810 ...(getThemeModes(editingTheme).length > 1
811 ? { variants: { [variantAppearance]: colorsForSave[variantAppearance] } }
812 : {}),
813 ...(isAdvanced ? {} : { managed: true }),
814 }),
815 ...(editingTheme.collection ? { collection: editingTheme.collection } : {}),
816 });
817 } else if (mergeTarget) {
818 if (takenAppearances.includes(activeAppearance)) {
819 setError(
820 `“${mergeTarget.label}” already has light and dark palettes. Pick another name.`,
821 );
822 return;
823 }
824 mergedAppearance = activeAppearance;
825 savedTheme = updateCustomTheme({
826 ...parseThemeFile({
827 version: THEME_FILE_VERSION,
828 id: mergeTarget.id,
829 name: mergeTarget.label,
830 appearance: mergeTarget.appearance,
831 colors: mergeTarget.colors,
832 variants: {
833 ...mergeTarget.variants,
834 [activeAppearance]: colorsForSave[activeAppearance],
835 },
836 ...(mergeTarget.managed === true && !isAdvanced ? { managed: true } : {}),
837 }),
838 ...(mergeTarget.collection ? { collection: mergeTarget.collection } : {}),
839 });
840 } else {
841 savedTheme = installCustomTheme(
842 parseThemeFile({
843 version: THEME_FILE_VERSION,
844 name,
845 appearance: activeAppearance,
846 colors: colorsForSave[activeAppearance],
847 ...(isAdvanced ? {} : { managed: true }),
848 }),
849 );
850 }
851 if (
852 !onSaved(savedTheme, {
853 created: editingTheme === null && mergedAppearance === null,
854 ...(mergedAppearance ? { mergedAppearance } : {}),
855 })
856 ) {
857 if (!editingTheme && mergedAppearance === null) {
858 try {
859 removeCustomTheme(savedTheme.id);
860 } catch {}
861 } else if (mergeTarget && mergedAppearance !== null) {
862 try {
863 updateCustomTheme(mergeTarget);
864 if (retiredTheme) installCustomTheme(retiredTheme);
865 } catch {}
866 }
867 setError("Theme saved, but it could not be made active. Try again.");
868 return;
869 }
870 onOpenChange(false);
871 } catch (cause) {
872 setError(
873 cause instanceof Error
874 ? cause.message
875 : isEditing
876 ? "Could not save the theme."
877 : "Could not create the theme.",
878 );
879 }
880 };
881
882 const renderNameField = () => (
883 <label className="grid grid-cols-[minmax(0,1fr)_minmax(0,2fr)] items-center gap-3">
884 <span className="text-sm font-medium">Theme name</span>
885 <Input
886 autoFocus
887 size="sm"
888 onChange={(event) => {
889 setName(event.currentTarget.value);
890 setError(null);
891 }}
892 placeholder={isEditing ? "Theme name" : "e.g. Aurora"}
893 value={name}
894 />
895 </label>
896 );
897
898 const renderAppearanceButton = (appearance: ThemeAppearance) => {
899 const lockReason = appearanceLockReason(appearance);
900 // Use aria-disabled so locked modes remain hoverable for explanatory tooltips.
901 const button = (
902 <Toggle aria-disabled={lockReason !== null} value={appearance}>
903 {appearance === "light" ? "Light" : "Dark"}
904 </Toggle>
905 );
906 if (lockReason === null) return button;
907 return (
908 <Tooltip>
909 <TooltipTrigger render={button} />
910 <TooltipPopup>{lockReason}</TooltipPopup>
911 </Tooltip>
912 );
913 };
914
915 const renderAppearanceButtons = () => (
916 <div className="grid grid-cols-[minmax(0,1fr)_minmax(0,2fr)] items-center gap-3">
917 <span className="text-sm font-medium">Appearance</span>
918 <ToggleGroup
919 aria-label="Theme appearance"
920 variant="segmented"
921 value={[activeAppearance]}
922 onValueChange={(next) => {
923 const appearance = next[0];
924 if (
925 (appearance === "light" || appearance === "dark") &&
926 appearanceLockReason(appearance) === null
927 ) {
928 setActiveAppearance(appearance);
929 }
930 }}
931 >
932 {renderAppearanceButton("light")}
933 {renderAppearanceButton("dark")}
934 </ToggleGroup>
935 </div>
936 );
937
938 const renderColorsHeader = () => (
939 <div className="grid grid-cols-[minmax(0,1fr)_minmax(0,2fr)] items-start gap-3">
940 <div>
941 <h3 className="text-sm font-medium">Colors</h3>
942 {isAdvanced ? null : (
943 <p className="text-xs text-muted-foreground">Two colors, rest derived</p>
944 )}
945 </div>
946 <div className="flex min-w-0 items-start gap-3">
947 {isAdvanced ? (
948 <Input
949 aria-label="Filter colors"
950 className="min-w-0 flex-1"
951 onChange={(event) => setRoleQuery(event.currentTarget.value)}
952 placeholder="Filter colors"
953 size="sm"
954 value={roleQuery}
955 />
956 ) : null}
957 <label className="ml-auto flex shrink-0 cursor-pointer items-center gap-2 pt-0.5 text-sm font-medium">
958 <span>Advanced</span>
959 <Switch
960 aria-label="Use advanced theme colors"
961 checked={isAdvanced}
962 onCheckedChange={(checked) => handleAdvancedChange(Boolean(checked))}
963 />
964 </label>
965 </div>
966 </div>
967 );
968
969 const renderRoleFields = (
970 families: ReadonlyArray<ThemeEditorColorFamily>,
971 gridClassName = "grid gap-2 sm:grid-cols-2",
972 ) => (
973 <div className={gridClassName}>
974 {families.map((family) => (
975 <ThemeColorField
976 key={family.id}
977 label={family.label}
978 onChange={updateColor}
979 onEditCancel={cancelColorEdit}
980 onEditStart={startColorEdit}
981 onSelect={selectThemeRole}
982 onToggleSelected={toggleThemeRole}
983 role={family.role}
984 selected={selectedRole === family.role}
985 value={colorsByAppearance[activeAppearance][family.role]}
986 />
987 ))}
988 </div>
989 );
990
991 const renderColorFields = () => {
992 const query = roleQuery.trim().toLowerCase();
993 const groups = THEME_EDITOR_ROLE_GROUPS.map((group) => ({
994 ...group,
995 families: group.families.filter(
996 (family) =>
997 !query ||
998 [family.label, ...family.roles.map((role) => getThemeRoleLabel(role))]
999 .join(" ")
1000 .toLowerCase()
1001 .includes(query),
1002 ),
1003 })).filter((group) => group.families.length > 0);
1004 return isAdvanced ? (
1005 <div className="space-y-5">
1006 {groups.map((group) => (
1007 <section className="space-y-2" key={group.id}>
1008 <h4 className="text-sm font-medium text-foreground">{group.title}</h4>
1009 {renderRoleFields(group.families, "grid gap-1")}
1010 </section>
1011 ))}
1012 {groups.length === 0 ? <p className="text-xs text-muted-foreground">No matches.</p> : null}
1013 </div>
1014 ) : (
1015 <div className="grid gap-1">
1016 {THEME_EDITOR_SIMPLE_ROLES.map((role) => (
1017 <ThemeColorField
1018 key={role}
1019 onChange={updateColor}
1020 onEditCancel={cancelColorEdit}
1021 onEditStart={startColorEdit}
1022 onSelect={selectThemeRole}
1023 onToggleSelected={toggleThemeRole}
1024 role={role}
1025 label={role === "canvas" ? "Background" : "Accent"}
1026 selected={selectedRole === role}
1027 value={colorsByAppearance[activeAppearance][role]}
1028 />
1029 ))}
1030 </div>
1031 );
1032 };
1033
1034 // Geometry is stored as the user left it and fitted to the current viewport here, so a
1035 // window that shrinks and grows back returns the panel to where it was.
1036 const viewport = useViewportSize();
1037 const shownSize = size && {
1038 width: Math.max(PANEL_MIN_WIDTH, Math.min(size.width, viewport.width - PANEL_MARGIN * 2)),
1039 height: Math.max(PANEL_MIN_HEIGHT, Math.min(size.height, viewport.height - PANEL_MARGIN * 2)),
1040 };
1041 const shownPosition =
1042 position &&
1043 clampPanelPosition(viewport, position.x, position.y, shownSize?.width ?? position.width);
1044
1045 const handleDragPointerDown = (event: ReactPointerEvent<HTMLDivElement>) => {
1046 if ((event.target as HTMLElement).closest("button, input, a")) return;
1047 const rect = panelRef.current?.getBoundingClientRect();
1048 if (!rect) return;
1049 dragOffsetRef.current = {
1050 dx: event.clientX - rect.x,
1051 dy: event.clientY - rect.y,
1052 width: rect.width,
1053 };
1054 event.currentTarget.setPointerCapture(event.pointerId);
1055 };
1056
1057 const handleDragPointerMove = (event: ReactPointerEvent<HTMLDivElement>) => {
1058 const offset = dragOffsetRef.current;
1059 if (!offset) return;
1060 const next = clampPanelPosition(
1061 readWindowViewport(),
1062 event.clientX - offset.dx,
1063 event.clientY - offset.dy,
1064 offset.width,
1065 );
1066 setPosition({ ...next, width: offset.width });
1067 };
1068
1069 const endDrag = () => {
1070 dragOffsetRef.current = null;
1071 };
1072
1073 const handleResizePointerDown = (event: ReactPointerEvent<HTMLDivElement>) => {
1074 const rect = panelRef.current?.getBoundingClientRect();
1075 if (!rect) return;
1076 event.preventDefault();
1077 // Resize from where the panel is drawn, so a position clamped after the window shrank, or bottom-right
1078 // parking, can't make the top-left corner slide.
1079 const next = clampPanelPosition(readWindowViewport(), rect.x, rect.y, rect.width);
1080 setPosition({ ...next, width: rect.width });
1081 resizeStartRef.current = {
1082 pointerX: event.clientX,
1083 pointerY: event.clientY,
1084 left: rect.x,
1085 top: rect.y,
1086 width: rect.width,
1087 height: rect.height,
1088 };
1089 event.currentTarget.setPointerCapture(event.pointerId);
1090 };
1091
1092 const handleResizePointerMove = (event: ReactPointerEvent<HTMLDivElement>) => {
1093 const start = resizeStartRef.current;
1094 if (!start) return;
1095 const maxWidth = Math.max(PANEL_MIN_WIDTH, window.innerWidth - PANEL_MARGIN - start.left);
1096 const maxHeight = Math.max(PANEL_MIN_HEIGHT, window.innerHeight - PANEL_MARGIN - start.top);
1097 setSize({
1098 width: Math.min(
1099 Math.max(start.width + event.clientX - start.pointerX, PANEL_MIN_WIDTH),
1100 maxWidth,
1101 ),
1102 height: Math.min(
1103 Math.max(start.height + event.clientY - start.pointerY, PANEL_MIN_HEIGHT),
1104 maxHeight,
1105 ),
1106 });
1107 };
1108
1109 const endResize = () => {
1110 resizeStartRef.current = null;
1111 };
1112
1113 return (
1114 <div
1115 aria-label={isEditing ? "Edit theme" : "Create theme"}
1116 className={cn(
1117 "dialog-glass fixed z-[110] flex max-h-[min(42rem,calc(100dvh-6rem))] w-[min(26rem,calc(100vw-2rem))] flex-col overflow-hidden rounded-xl border text-popover-foreground",
1118 position === null && "bottom-4 right-4",
1119 isMinimized && "max-h-none",
1120 )}
1121 data-theme-editor-panel
1122 ref={panelRef}
1123 role="dialog"
1124 style={{
1125 ...(shownPosition ? { left: shownPosition.x, top: shownPosition.y } : {}),
1126 ...(shownSize ? { width: shownSize.width } : {}),
1127 ...(shownSize && !isMinimized
1128 ? { height: shownSize.height, maxHeight: "calc(100dvh - 1rem)" }
1129 : {}),
1130 }}
1131 >
1132 <div
1133 className="flex cursor-grab touch-none select-none items-center gap-1 border-b border-border/70 px-3 py-2 active:cursor-grabbing"
1134 onPointerCancel={endDrag}
1135 onPointerDown={handleDragPointerDown}
1136 onPointerMove={handleDragPointerMove}
1137 onPointerUp={endDrag}
1138 >
1139 <div className="flex min-w-0 flex-1 items-baseline gap-2">
1140 <h2 className="shrink-0 truncate text-sm font-medium">
1141 {isEditing ? "Edit theme" : "Create theme"}
1142 </h2>
1143 {isMinimized ? null : (
1144 <p className="truncate text-xs text-muted-foreground">
1145 {isInspecting
1146 ? "Select an element · Esc to cancel"
1147 : selectedRole
1148 ? `${isAdvanced ? (getThemeEditorColorFamily(selectedRole)?.label ?? getThemeRoleLabel(selectedRole)) : getThemeRoleLabel(selectedRole)} · ${usageCount ?? 0} ${usageCount === 1 ? "use" : "uses"}`
1149 : "Select a color below"}
1150 </p>
1151 )}
1152 </div>
1153 <Tooltip>
1154 <TooltipTrigger
1155 render={
1156 <Button
1157 aria-label={isInspecting ? "Cancel inspecting app colors" : "Inspect app colors"}
1158 aria-pressed={isInspecting}
1159 size="xs"
1160 variant={isInspecting ? "secondary" : "ghost"}
1161 onClick={() => {
1162 if (isInspecting) {
1163 clearInspectorSelection();
1164 return;
1165 }
1166 setIsInspecting(true);
1167 }}
1168 >
1169 <MousePointer2Icon />
1170 {isInspecting ? "Cancel" : "Inspect"}
1171 </Button>
1172 }
1173 />
1174 <TooltipPopup data-theme-editor-panel="">
1175 {isInspecting ? "Cancel and clear the selection" : "Pick a color from the app"}
1176 </TooltipPopup>
1177 </Tooltip>
1178 <Button
1179 aria-label={isMinimized ? "Expand the theme editor" : "Minimize the theme editor"}
1180 size="icon-xs"
1181 variant="ghost"
1182 onClick={() => setIsMinimized(!isMinimized)}
1183 >
1184 {isMinimized ? <ChevronUpIcon /> : <ChevronDownIcon />}
1185 </Button>
1186 <Button
1187 aria-label="Close the theme editor"
1188 size="icon-xs"
1189 variant="ghost"
1190 onClick={() => onOpenChange(false)}
1191 >
1192 <XIcon />
1193 </Button>
1194 </div>
1195
1196 {isMinimized ? null : (
1197 <>
1198 <div className="min-h-0 flex-1 space-y-3 overflow-y-auto py-3 pl-3 pr-1.5">
1199 {renderNameField()}
1200 {error ? (
1201 <p aria-live="polite" className="text-sm text-destructive">
1202 {error}
1203 </p>
1204 ) : null}
1205 {renderAppearanceButtons()}
1206 <div className="space-y-3">
1207 {renderColorsHeader()}
1208 {renderColorFields()}
1209 </div>
1210 </div>
1211 <div className="flex items-center justify-end gap-2 border-t border-border/70 px-3 py-2">
1212 <Button size="sm" variant="ghost" onClick={() => onOpenChange(false)}>
1213 Cancel
1214 </Button>
1215 <Button disabled={!name.trim()} size="sm" onClick={handleSubmit}>
1216 {isEditing ? (
1217 mergeTarget ? (
1218 `Merge into “${mergeTarget.label}”`
1219 ) : (
1220 "Save changes"
1221 )
1222 ) : mergeTarget ? (
1223 <>
1224 <PlusIcon />
1225 {`Add ${activeAppearance} palette`}
1226 </>
1227 ) : (
1228 <>
1229 <PaintbrushIcon />
1230 Create theme
1231 </>
1232 )}
1233 </Button>
1234 </div>
1235 <div
1236 aria-hidden
1237 className="absolute bottom-0 right-0 z-10 flex size-5 cursor-se-resize touch-none select-none items-end justify-end p-1 text-muted-foreground/70"
1238 onPointerCancel={endResize}
1239 onPointerDown={handleResizePointerDown}
1240 onPointerMove={handleResizePointerMove}
1241 onPointerUp={endResize}
1242 >
1243 <svg
1244 className="size-2.5"
1245 fill="none"
1246 stroke="currentColor"
1247 strokeLinecap="round"
1248 strokeWidth="1.2"
1249 viewBox="0 0 8 8"
1250 >
1251 <path d="M7 1 1 7M7 4.5 4.5 7" />
1252 </svg>
1253 </div>
1254 </>
1255 )}
1256 </div>
1257 );
1258}