The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { describe, expect, it } from "vite-plus/test"; |
| 2 | |
| 3 | import { |
| 4 | getThemeColorsForMode, |
| 5 | parseThemeFile, |
| 6 | themeColorToHex, |
| 7 | THEME_FILE_VERSION, |
| 8 | toCanonicalThemeColor, |
| 9 | } from "./themePalette"; |
| 10 | import { |
| 11 | isVsCodeThemeFile, |
| 12 | pairVsCodeThemes, |
| 13 | parseThemeImport, |
| 14 | parseVsCodeThemeFile, |
| 15 | resolveThemeLabelCollisions, |
| 16 | } from "./vscodeThemeImport"; |
| 17 | |
| 18 | function asHex(value: string): string { |
| 19 | const hex = themeColorToHex(value); |
| 20 | if (!hex) throw new Error(`Expected a theme color, received ${value}`); |
| 21 | return hex; |
| 22 | } |
| 23 | |
| 24 | function contrastRatio(first: string, second: string): number { |
| 25 | const toChannels = (value: string) => { |
| 26 | const hex = asHex(value).slice(1); |
| 27 | return [0, 1, 2].map( |
| 28 | (channel) => Number.parseInt(hex.slice(channel * 2, channel * 2 + 2), 16) / 255, |
| 29 | ); |
| 30 | }; |
| 31 | const luminance = (value: string) => |
| 32 | toChannels(value) |
| 33 | .map((channel) => (channel <= 0.03928 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4)) |
| 34 | .reduce((sum, channel, index) => sum + channel * [0.2126, 0.7152, 0.0722][index]!, 0); |
| 35 | const lighter = Math.max(luminance(first), luminance(second)); |
| 36 | const darker = Math.min(luminance(first), luminance(second)); |
| 37 | return (lighter + 0.05) / (darker + 0.05); |
| 38 | } |
| 39 | |
| 40 | function oklchParts(value: string): { chroma: number; hue: number } { |
| 41 | const [, chroma, hue] = /^oklch\(\S+ (\S+) (\S+)\)$/.exec(value)!; |
| 42 | return { chroma: Number(chroma), hue: Number(hue) }; |
| 43 | } |
| 44 | |
| 45 | const VSCODE_DARK = { |
| 46 | name: "pierre-dark-soft", |
| 47 | type: "dark", |
| 48 | colors: { |
| 49 | "editor.background": "#171717", |
| 50 | "editor.foreground": "#d4d4d4", |
| 51 | foreground: "#d4d4d4", |
| 52 | "sideBar.background": "#101010", |
| 53 | "sideBar.foreground": "#8a8a8a", |
| 54 | "sideBar.border": "#1d1d1d", |
| 55 | focusBorder: "#69b1ff", |
| 56 | "button.background": "#69b1ff", |
| 57 | "button.foreground": "#171717", |
| 58 | "input.border": "#2c2c2c", |
| 59 | "input.placeholderForeground": "#525252", |
| 60 | "terminal.background": "#101010", |
| 61 | "terminal.foreground": "#8a8a8a", |
| 62 | "list.hoverBackground": "#1f3e5e59", |
| 63 | "list.activeSelectionBackground": "#1f3e5e99", |
| 64 | }, |
| 65 | tokenColors: [], |
| 66 | }; |
| 67 | |
| 68 | describe("theme import text", () => { |
| 69 | it("preserves conversion of ordinary VS Code JSON", () => { |
| 70 | expect(parseThemeImport(JSON.stringify(VSCODE_DARK))).toEqual( |
| 71 | parseVsCodeThemeFile(VSCODE_DARK), |
| 72 | ); |
| 73 | }); |
| 74 | |
| 75 | it.each([ |
| 76 | '{ // line comment\n "name": "Test", "colors": { "editor.background": "#002b36" } }', |
| 77 | '{ /* block comment */ "name": "Test", "colors": { "editor.background": "#002b36" } }', |
| 78 | '{ "name": "Test", "colors": { "editor.background": "#002b36", }, "tokenColors": [ { "scope": ["comment",], "settings": {}, }, ], }', |
| 79 | ])("imports VS Code JSONC without changing conversion: %s", (source) => { |
| 80 | const theme = parseThemeImport(source); |
| 81 | expect(theme.label).toBe("Test"); |
| 82 | expect(theme.appearance).toBe("dark"); |
| 83 | expect(asHex(theme.colors.canvas)).toBe("#002b36"); |
| 84 | }); |
| 85 | |
| 86 | it.each([ |
| 87 | "", |
| 88 | '{ "name": "Test", "colors": { "editor.background": "#002b36" }', |
| 89 | '{ "name": "Test" "colors": { "editor.background": "#002b36" } }', |
| 90 | '{ "name": "Test", "colors": { "editor.background": "#002b36" } } /* unterminated', |
| 91 | '{ "name": "Test", "colors": { "editor.background": "#002b36" } } extra', |
| 92 | ])("rejects malformed input rather than using parser recovery: %s", (source) => { |
| 93 | expect(() => parseThemeImport(source)).toThrow("That theme file is not valid JSON."); |
| 94 | }); |
| 95 | |
| 96 | it("preserves native T3 theme parsing and strict JSON syntax", () => { |
| 97 | const nativeTheme = { |
| 98 | version: THEME_FILE_VERSION, |
| 99 | name: "Native theme", |
| 100 | appearance: "dark", |
| 101 | colors: { canvas: "#002b36" }, |
| 102 | }; |
| 103 | const source = JSON.stringify(nativeTheme); |
| 104 | expect(parseThemeImport(source)).toEqual(parseThemeFile(nativeTheme)); |
| 105 | expect(() => parseThemeImport(source.replace("{", "{ /* native theme */"))).toThrow(); |
| 106 | expect(() => parseThemeImport(source.slice(0, -1) + ",}")).toThrow(); |
| 107 | }); |
| 108 | |
| 109 | it("still validates theme structure after parsing JSONC", () => { |
| 110 | expect(() => |
| 111 | parseThemeImport('{ /* not a theme */ "colors": { "editor.foreground": "#fff" } }'), |
| 112 | ).toThrow('no "editor.background"'); |
| 113 | expect(() => |
| 114 | parseThemeImport( |
| 115 | '{ "version": 1, "name": "Bad native", "appearance": "dark", "colors": { "unknown": "#fff" } }', |
| 116 | ), |
| 117 | ).toThrow('"unknown" is not a supported theme color role.'); |
| 118 | }); |
| 119 | }); |
| 120 | |
| 121 | describe("VS Code theme import", () => { |
| 122 | it("recognises workbench themes and rejects our own files", () => { |
| 123 | expect(isVsCodeThemeFile(VSCODE_DARK)).toBe(true); |
| 124 | expect(isVsCodeThemeFile({ type: "dark", tokenColors: [] })).toBe(true); |
| 125 | expect( |
| 126 | isVsCodeThemeFile({ |
| 127 | version: THEME_FILE_VERSION, |
| 128 | name: "Aurora", |
| 129 | appearance: "light", |
| 130 | colors: { canvas: "#ffffff" }, |
| 131 | }), |
| 132 | ).toBe(false); |
| 133 | expect(isVsCodeThemeFile("nope")).toBe(false); |
| 134 | }); |
| 135 | |
| 136 | it("carries the editor surfaces and accent across", () => { |
| 137 | const theme = parseVsCodeThemeFile(VSCODE_DARK); |
| 138 | expect(theme.label).toBe("Pierre Dark Soft"); |
| 139 | expect(theme.appearance).toBe("dark"); |
| 140 | expect(asHex(theme.colors.canvas)).toBe("#171717"); |
| 141 | expect(asHex(theme.colors.text)).toBe("#d4d4d4"); |
| 142 | expect(asHex(theme.colors.accent)).toBe("#69b1ff"); |
| 143 | expect(asHex(theme.colors.sidebar)).toBe("#101010"); |
| 144 | expect(asHex(theme.colors.terminalBackground)).toBe("#101010"); |
| 145 | }); |
| 146 | |
| 147 | it("keeps a fallback placeholder dimmer than entered text", () => { |
| 148 | const theme = parseVsCodeThemeFile({ |
| 149 | name: "Dark placeholder fallback", |
| 150 | type: "dark", |
| 151 | colors: { |
| 152 | "editor.background": "#1e1e2e", |
| 153 | "editor.foreground": "#cdd6f4", |
| 154 | "input.placeholderForeground": "#cdd6f473", |
| 155 | }, |
| 156 | }); |
| 157 | |
| 158 | expect( |
| 159 | contrastRatio(theme.colors.placeholder, theme.colors.surfaceRaised), |
| 160 | ).toBeGreaterThanOrEqual(4.5); |
| 161 | expect(contrastRatio(theme.colors.placeholder, theme.colors.canvas)).toBeGreaterThanOrEqual( |
| 162 | 4.5, |
| 163 | ); |
| 164 | expect(contrastRatio(theme.colors.placeholder, theme.colors.canvas)).toBeLessThan( |
| 165 | contrastRatio(theme.colors.text, theme.colors.canvas), |
| 166 | ); |
| 167 | }); |
| 168 | |
| 169 | it("moves reserved VS Code names to a non-reserved id", () => { |
| 170 | const darkPlus = parseVsCodeThemeFile({ |
| 171 | name: "Dark+", |
| 172 | type: "dark", |
| 173 | colors: { "editor.background": "#1e1e1e" }, |
| 174 | }); |
| 175 | expect(darkPlus.label).toBe("Dark+"); |
| 176 | expect(darkPlus.id).not.toBe("dark"); |
| 177 | expect(darkPlus.id).toBe("dark-vscode"); |
| 178 | }); |
| 179 | |
| 180 | it("keeps Dark+ and Light+ as separate themes instead of pairing them as +", () => { |
| 181 | const themes = pairVsCodeThemes([ |
| 182 | parseVsCodeThemeFile({ |
| 183 | name: "Light+", |
| 184 | type: "light", |
| 185 | colors: { "editor.background": "#ffffff" }, |
| 186 | }), |
| 187 | parseVsCodeThemeFile({ |
| 188 | name: "Dark+", |
| 189 | type: "dark", |
| 190 | colors: { "editor.background": "#1e1e1e" }, |
| 191 | }), |
| 192 | ]); |
| 193 | expect(themes.map((theme) => [theme.id, theme.label])).toEqual([ |
| 194 | ["light-vscode", "Light+"], |
| 195 | ["dark-vscode", "Dark+"], |
| 196 | ]); |
| 197 | }); |
| 198 | |
| 199 | it("prefers a visible input background over a transparent border", () => { |
| 200 | const catppuccin = parseVsCodeThemeFile({ |
| 201 | name: "Catppuccin Mocha", |
| 202 | type: "dark", |
| 203 | colors: { |
| 204 | "editor.background": "#1e1e2e", |
| 205 | "input.border": "#00000000", |
| 206 | "input.background": "#313244", |
| 207 | }, |
| 208 | }); |
| 209 | expect(asHex(catppuccin.colors.input)).toBe("#313244"); |
| 210 | }); |
| 211 | |
| 212 | it("keeps unchecked inputs distinct from the checked action color", () => { |
| 213 | const gruvbox = parseVsCodeThemeFile({ |
| 214 | name: "Gruvbox Light Soft", |
| 215 | type: "light", |
| 216 | colors: { |
| 217 | "editor.background": "#f2e5bc", |
| 218 | "button.background": "#45858880", |
| 219 | "input.background": "#45858880", |
| 220 | "input.border": "#928374", |
| 221 | }, |
| 222 | }); |
| 223 | expect( |
| 224 | contrastRatio(gruvbox.colors.input, gruvbox.colors.messageAction), |
| 225 | ).toBeGreaterThanOrEqual(1.1); |
| 226 | }); |
| 227 | |
| 228 | it("skips a transparent focus border for a visible accent key", () => { |
| 229 | const vitesse = parseVsCodeThemeFile({ |
| 230 | name: "Vitesse Dark", |
| 231 | type: "dark", |
| 232 | colors: { |
| 233 | "editor.background": "#121212", |
| 234 | focusBorder: "#00000000", |
| 235 | "button.background": "#4d9375", |
| 236 | }, |
| 237 | }); |
| 238 | expect(asHex(vitesse.colors.accent)).toBe("#4d9375"); |
| 239 | expect(asHex(vitesse.colors.focus)).toBe("#4d9375"); |
| 240 | expect(contrastRatio(vitesse.colors.focus, vitesse.colors.canvas)).toBeGreaterThanOrEqual(1.1); |
| 241 | }); |
| 242 | |
| 243 | it("keeps focus visible against an explicit raised surface", () => { |
| 244 | const theme = parseVsCodeThemeFile({ |
| 245 | name: "Raised focus", |
| 246 | type: "dark", |
| 247 | colors: { |
| 248 | "editor.background": "#000000", |
| 249 | focusBorder: "#111111", |
| 250 | "editorWidget.background": "#111111", |
| 251 | "button.background": "#4d9375", |
| 252 | }, |
| 253 | }); |
| 254 | expect(contrastRatio(theme.colors.focus, theme.colors.surfaceRaised)).toBeGreaterThanOrEqual( |
| 255 | 1.1, |
| 256 | ); |
| 257 | expect(asHex(theme.colors.focus)).toBe("#4d9375"); |
| 258 | }); |
| 259 | |
| 260 | it("skips a transparent button background for the action color", () => { |
| 261 | const theme = parseVsCodeThemeFile({ |
| 262 | name: "Transparent button", |
| 263 | type: "dark", |
| 264 | colors: { |
| 265 | "editor.background": "#121212", |
| 266 | focusBorder: "#4d9375", |
| 267 | "button.background": "#00000000", |
| 268 | }, |
| 269 | }); |
| 270 | expect(asHex(theme.colors.messageAction)).toBe("#4d9375"); |
| 271 | }); |
| 272 | it("composites find backgrounds onto the canvas and foregrounds onto their match", () => { |
| 273 | const { colors } = parseVsCodeThemeFile({ |
| 274 | type: "dark", |
| 275 | colors: { |
| 276 | "editor.background": "#202020", |
| 277 | "editor.findMatchBackground": "#33669980", |
| 278 | "editor.findMatchForeground": "#ffffffcc", |
| 279 | "editor.findMatchHighlightBackground": "#ffcc0040", |
| 280 | "editor.findMatchHighlightForeground": "#ffffff", |
| 281 | }, |
| 282 | }); |
| 283 | |
| 284 | expect(asHex(colors.searchMatchActiveBackground)).toBe("#2a435d"); |
| 285 | expect(asHex(colors.searchMatchActiveForeground)).toBe("#d4d9df"); |
| 286 | expect(asHex(colors.searchMatchBackground)).toBe("#584b18"); |
| 287 | expect(asHex(colors.searchMatchForeground)).toBe("#ffffff"); |
| 288 | }); |
| 289 | |
| 290 | it.each(["light", "dark"])( |
| 291 | "keeps missing or invalid find colours readable in %s themes", |
| 292 | (type) => { |
| 293 | const base = { |
| 294 | "editor.background": type === "dark" ? "#101010" : "#fafafa", |
| 295 | }; |
| 296 | const missing = parseVsCodeThemeFile({ type, colors: base }).colors; |
| 297 | const invalid = parseVsCodeThemeFile({ |
| 298 | type, |
| 299 | colors: { |
| 300 | ...base, |
| 301 | "editor.findMatchBackground": "not-a-colour", |
| 302 | "editor.findMatchForeground": 42, |
| 303 | "editor.findMatchHighlightBackground": null, |
| 304 | "editor.findMatchHighlightForeground": "invalid", |
| 305 | }, |
| 306 | }).colors; |
| 307 | const unreadable = parseVsCodeThemeFile({ |
| 308 | type, |
| 309 | colors: { |
| 310 | ...base, |
| 311 | "editor.findMatchBackground": "#ffffcc", |
| 312 | "editor.findMatchForeground": "#ffffff", |
| 313 | "editor.findMatchHighlightBackground": "#101020", |
| 314 | "editor.findMatchHighlightForeground": "#111111", |
| 315 | }, |
| 316 | }).colors; |
| 317 | |
| 318 | for (const colors of [missing, invalid, unreadable]) { |
| 319 | expect( |
| 320 | contrastRatio(colors.searchMatchForeground, colors.searchMatchBackground), |
| 321 | ).toBeGreaterThanOrEqual(4.5); |
| 322 | expect( |
| 323 | contrastRatio(colors.searchMatchActiveForeground, colors.searchMatchActiveBackground), |
| 324 | ).toBeGreaterThanOrEqual(4.5); |
| 325 | } |
| 326 | expect(invalid.searchMatchBackground).toBe(missing.searchMatchBackground); |
| 327 | expect(invalid.searchMatchActiveBackground).toBe(missing.searchMatchActiveBackground); |
| 328 | expect(missing.searchMatchBackground).not.toBe(missing.searchMatchActiveBackground); |
| 329 | expect(missing.searchMatchBackground).not.toBe(missing.canvas); |
| 330 | expect(missing.searchMatchActiveBackground).not.toBe(missing.canvas); |
| 331 | }, |
| 332 | ); |
| 333 | |
| 334 | it("fills every role the file omits with a readable derived value", () => { |
| 335 | const theme = parseVsCodeThemeFile(VSCODE_DARK); |
| 336 | const colors = getThemeColorsForMode(theme, "dark")!; |
| 337 | for (const value of Object.values(colors)) { |
| 338 | expect(value).toMatch(/^oklch\(/); |
| 339 | } |
| 340 | expect(contrastRatio(colors.text, colors.canvas)).toBeGreaterThanOrEqual(4.5); |
| 341 | expect(contrastRatio(colors.sidebarForeground, colors.sidebar)).toBeGreaterThanOrEqual(4.5); |
| 342 | expect( |
| 343 | contrastRatio(colors.messageActionForeground, colors.messageAction), |
| 344 | ).toBeGreaterThanOrEqual(4.5); |
| 345 | }); |
| 346 | |
| 347 | it("falls back to the editor background when the type is missing or odd", () => { |
| 348 | const untyped = parseVsCodeThemeFile({ |
| 349 | name: "Untyped", |
| 350 | colors: { "editor.background": "#fdfdfd", "editor.foreground": "#202020" }, |
| 351 | }); |
| 352 | expect(untyped.appearance).toBe("light"); |
| 353 | const hc = parseVsCodeThemeFile({ |
| 354 | name: "High contrast", |
| 355 | type: "hc-light", |
| 356 | colors: { "editor.background": "#ffffff" }, |
| 357 | }); |
| 358 | expect(hc.appearance).toBe("light"); |
| 359 | }); |
| 360 | |
| 361 | it.each([ |
| 362 | ["dark", "#282828"], |
| 363 | ["light", "#ffffff"], |
| 364 | ] as const)( |
| 365 | "keeps a dim status color's hue on a %s canvas instead of replacing it", |
| 366 | (type, canvas) => { |
| 367 | const theme = parseVsCodeThemeFile({ |
| 368 | name: "Gruvbox", |
| 369 | type, |
| 370 | colors: { |
| 371 | "editor.background": canvas, |
| 372 | "editorError.foreground": "#fb4934", |
| 373 | "editorWarning.foreground": "#b57614", |
| 374 | }, |
| 375 | }); |
| 376 | for (const [role, source] of [ |
| 377 | ["error", "#fb4934"], |
| 378 | ["warning", "#b57614"], |
| 379 | ] as const) { |
| 380 | const imported = oklchParts(theme.colors[role]); |
| 381 | expect(contrastRatio(theme.colors[role], theme.colors.canvas)).toBeGreaterThanOrEqual(4.5); |
| 382 | expect(imported.chroma).toBeGreaterThan(0.1); |
| 383 | // 8-bit sRGB can only approximate the source hue at the new lightness. |
| 384 | expect( |
| 385 | Math.abs(imported.hue - oklchParts(toCanonicalThemeColor(source)!).hue), |
| 386 | ).toBeLessThan(2); |
| 387 | } |
| 388 | }, |
| 389 | ); |
| 390 | |
| 391 | it("keeps the derived status color when the file hides its own", () => { |
| 392 | const theme = parseVsCodeThemeFile({ |
| 393 | name: "Hidden squiggles", |
| 394 | type: "dark", |
| 395 | colors: { "editor.background": "#101010", "editorError.foreground": "#ff000000" }, |
| 396 | }); |
| 397 | expect(oklchParts(theme.colors.error).chroma).toBeGreaterThan(0.1); |
| 398 | }); |
| 399 | |
| 400 | it("stays readable when the file replaces a surface but not its foreground", () => { |
| 401 | const theme = parseVsCodeThemeFile({ |
| 402 | name: "Split", |
| 403 | type: "dark", |
| 404 | colors: { |
| 405 | "editor.background": "#101010", |
| 406 | "editor.foreground": "#f5f5f5", |
| 407 | "sideBar.background": "#fafafa", |
| 408 | "terminal.background": "#fbfbfb", |
| 409 | }, |
| 410 | }); |
| 411 | expect(asHex(theme.colors.sidebar)).toBe("#fafafa"); |
| 412 | expect( |
| 413 | contrastRatio(theme.colors.sidebarForeground, theme.colors.sidebar), |
| 414 | ).toBeGreaterThanOrEqual(4.5); |
| 415 | expect( |
| 416 | contrastRatio(theme.colors.terminalForeground, theme.colors.terminalBackground), |
| 417 | ).toBeGreaterThanOrEqual(4.5); |
| 418 | }); |
| 419 | |
| 420 | it("reads wide-gamut color() notation", () => { |
| 421 | const theme = parseVsCodeThemeFile({ |
| 422 | name: "Vibrant", |
| 423 | type: "dark", |
| 424 | colors: { |
| 425 | "editor.background": "color(display-p3 0.039216 0.039216 0.039216)", |
| 426 | "editor.foreground": "color(display-p3 0.980392 0.980392 0.980392)", |
| 427 | focusBorder: "color(display-p3 0.308664 0.645271 1.000000)", |
| 428 | "editor.selectionBackground": "color(display-p3 0.308664 0.645271 1.000000 / 0.300000)", |
| 429 | }, |
| 430 | }); |
| 431 | expect(asHex(theme.colors.canvas)).toMatch(/^#0[89ab]/); |
| 432 | expect(asHex(theme.colors.text)).toMatch(/^#f[a-f0-9]/); |
| 433 | const accent = asHex(theme.colors.accent); |
| 434 | const [red, green, blue] = [1, 3, 5].map((index) => |
| 435 | Number.parseInt(accent.slice(index, index + 2), 16), |
| 436 | ) as [number, number, number]; |
| 437 | expect(blue).toBeGreaterThan(200); |
| 438 | expect(blue).toBeGreaterThan(red); |
| 439 | expect(green).toBeGreaterThan(red); |
| 440 | }); |
| 441 | |
| 442 | it("pairs light and dark files from one family into dual-mode themes", () => { |
| 443 | const make = (name: string, type: "light" | "dark") => |
| 444 | parseVsCodeThemeFile({ |
| 445 | name, |
| 446 | type, |
| 447 | colors: { |
| 448 | "editor.background": type === "dark" ? "#101014" : "#fdfdfd", |
| 449 | "editor.foreground": type === "dark" ? "#e6e6e6" : "#1f1f1f", |
| 450 | focusBorder: "#69b1ff", |
| 451 | }, |
| 452 | }); |
| 453 | const themes = pairVsCodeThemes([ |
| 454 | make("github-dark", "dark"), |
| 455 | make("github-light", "light"), |
| 456 | make("github-dark-colorblind", "dark"), |
| 457 | make("github-light-colorblind", "light"), |
| 458 | make("github-dark-dimmed", "dark"), |
| 459 | ]); |
| 460 | |
| 461 | const labels = themes.map((theme) => theme.label); |
| 462 | expect(labels).toEqual(["Github", "Github Colorblind", "Github Dark Dimmed"]); |
| 463 | const github = themes[0]!; |
| 464 | expect(github.appearance).toBe("light"); |
| 465 | expect(getThemeColorsForMode(github, "dark")).not.toBeNull(); |
| 466 | expect(asHex(getThemeColorsForMode(github, "dark")!.canvas)).toBe("#101014"); |
| 467 | expect(asHex(github.colors.canvas)).toBe("#fdfdfd"); |
| 468 | expect(getThemeColorsForMode(themes[2]!, "light")).toBeNull(); |
| 469 | }); |
| 470 | |
| 471 | it.each([ |
| 472 | { name: "shared", light: "a {}", dark: "a {}", expected: [["Aurora", "a {}"]] }, |
| 473 | { name: "light-only", light: "a {}", dark: undefined, expected: [["Aurora", "a {}"]] }, |
| 474 | { name: "dark-only", light: undefined, dark: "a {}", expected: [["Aurora", "a {}"]] }, |
| 475 | { |
| 476 | name: "conflicting", |
| 477 | light: "a {}", |
| 478 | dark: "b {}", |
| 479 | expected: [ |
| 480 | ["Aurora Light", "a {}"], |
| 481 | ["Aurora Dark", "b {}"], |
| 482 | ], |
| 483 | }, |
| 484 | ])("pairs light and dark halves with $name custom CSS", ({ light, dark, expected }) => { |
| 485 | const themes = pairVsCodeThemes( |
| 486 | (["light", "dark"] as const).map((appearance) => { |
| 487 | const css = appearance === "light" ? light : dark; |
| 488 | return parseThemeFile({ |
| 489 | version: THEME_FILE_VERSION, |
| 490 | name: `Aurora ${appearance === "light" ? "Light" : "Dark"}`, |
| 491 | appearance, |
| 492 | colors: { canvas: appearance === "light" ? "#fafafa" : "#101014" }, |
| 493 | ...(css ? { css } : {}), |
| 494 | }); |
| 495 | }), |
| 496 | ); |
| 497 | expect(themes.map((theme) => [theme.label, theme.css])).toEqual(expected); |
| 498 | }); |
| 499 | |
| 500 | it("does not guess when a family is ambiguous", () => { |
| 501 | const make = (name: string, type: "light" | "dark") => |
| 502 | parseVsCodeThemeFile({ |
| 503 | name, |
| 504 | type, |
| 505 | colors: { "editor.background": type === "dark" ? "#101014" : "#fdfdfd" }, |
| 506 | }); |
| 507 | const themes = pairVsCodeThemes([ |
| 508 | make("solar-dark", "dark"), |
| 509 | make("solar-dark-soft", "dark"), |
| 510 | make("solar-light", "light"), |
| 511 | ]); |
| 512 | expect(themes.map((theme) => theme.label).sort()).toEqual(["Solar", "Solar Dark Soft"]); |
| 513 | }); |
| 514 | |
| 515 | it("tells same-named variants apart by their file names", () => { |
| 516 | // Both Dracula theme files declare the same internal name. |
| 517 | const css = ".app { outline: 1px solid red; }"; |
| 518 | const dracula = (bg: string) => ({ |
| 519 | ...parseVsCodeThemeFile({ |
| 520 | name: "Dracula", |
| 521 | type: "dark", |
| 522 | colors: { "editor.background": bg, "editor.foreground": "#f8f8f2" }, |
| 523 | }), |
| 524 | css, |
| 525 | }); |
| 526 | const themes = resolveThemeLabelCollisions([ |
| 527 | { theme: dracula("#282a36"), sourceName: "dracula.json" }, |
| 528 | { theme: dracula("#22232e"), sourceName: "dracula-soft.json" }, |
| 529 | ]); |
| 530 | expect(themes.map((theme) => theme.label)).toEqual(["Dracula", "Dracula Soft"]); |
| 531 | expect(themes.map((theme) => theme.id)).toEqual(["dracula", "dracula-soft"]); |
| 532 | expect(themes.map((theme) => theme.css)).toEqual([css, css]); |
| 533 | const numbered = resolveThemeLabelCollisions([ |
| 534 | { theme: dracula("#282a36") }, |
| 535 | { theme: dracula("#22232e") }, |
| 536 | ]); |
| 537 | expect(numbered.map((theme) => theme.label)).toEqual(["Dracula", "Dracula 2"]); |
| 538 | expect(numbered.map((theme) => theme.css)).toEqual([css, css]); |
| 539 | }); |
| 540 | |
| 541 | const darkVsCodeTheme = (name: string, background: string) => |
| 542 | parseVsCodeThemeFile({ |
| 543 | name, |
| 544 | type: "dark", |
| 545 | colors: { "editor.background": background, "editor.foreground": "#cdd6f4" }, |
| 546 | }); |
| 547 | |
| 548 | it("keeps both digits of a suffix when a one-digit suffix just fits", () => { |
| 549 | const name = "GitHub Dark High Contrast Deuteranopia Preview"; |
| 550 | const backgrounds = [ |
| 551 | "#1e1e2e", |
| 552 | "#25203b", |
| 553 | "#152a26", |
| 554 | "#181825", |
| 555 | "#11111b", |
| 556 | "#232136", |
| 557 | "#101014", |
| 558 | "#24273a", |
| 559 | "#282a36", |
| 560 | "#22232e", |
| 561 | ]; |
| 562 | const themes = resolveThemeLabelCollisions( |
| 563 | backgrounds.map((background) => ({ theme: darkVsCodeTheme(name, background) })), |
| 564 | ); |
| 565 | expect(themes.map((theme) => theme.label)).toEqual([ |
| 566 | name, |
| 567 | ...Array.from({ length: 8 }, (_, index) => `${name} ${index + 2}`), |
| 568 | "GitHub Dark High Contrast Deuteranopia Previe 10", |
| 569 | ]); |
| 570 | expect(new Set(themes.map((theme) => theme.id)).size).toBe(backgrounds.length); |
| 571 | }); |
| 572 | |
| 573 | it.each([ |
| 574 | { |
| 575 | name: "Catppuccin Mocha High Contrast Accessible v2 🌙", |
| 576 | numberedBase: "Catppuccin Mocha High Contrast Accessible v2", |
| 577 | }, |
| 578 | { |
| 579 | name: "İstanbul İncisi İzmir İskenderun İnegöl İpsala", |
| 580 | numberedBase: "İstanbul İncisi İzmir İskenderun İnegöl İ", |
| 581 | }, |
| 582 | ])("keeps all numbered variants of $name", ({ name, numberedBase }) => { |
| 583 | const themes = resolveThemeLabelCollisions( |
| 584 | ["#1e1e2e", "#25203b", "#152a26"].map((background) => ({ |
| 585 | theme: darkVsCodeTheme(name, background), |
| 586 | })), |
| 587 | ); |
| 588 | expect(themes.map((theme) => theme.label)).toEqual([ |
| 589 | name, |
| 590 | `${numberedBase} 2`, |
| 591 | `${numberedBase} 3`, |
| 592 | ]); |
| 593 | expect(new Set(themes.map((theme) => theme.id)).size).toBe(3); |
| 594 | }); |
| 595 | |
| 596 | it("does not take the ID of a later theme already named with that number", () => { |
| 597 | const name = "Catppuccin Mocha High Contrast Accessible Themes"; |
| 598 | const numberedBase = "Catppuccin Mocha High Contrast Accessible Them"; |
| 599 | const duplicates = ["#1e1e2e", "#25203b"].map((background) => ({ |
| 600 | theme: darkVsCodeTheme(name, background), |
| 601 | })); |
| 602 | const peer = { theme: darkVsCodeTheme(`${numberedBase} 2`, "#152a26") }; |
| 603 | const themes = resolveThemeLabelCollisions([...duplicates, peer]); |
| 604 | expect(themes.map(({ label }) => label)).toEqual([ |
| 605 | name, |
| 606 | `${numberedBase} 3`, |
| 607 | `${numberedBase} 2`, |
| 608 | ]); |
| 609 | expect(themes.find(({ id }) => id === peer.theme.id)?.colors.canvas).toBe( |
| 610 | peer.theme.colors.canvas, |
| 611 | ); |
| 612 | }); |
| 613 | |
| 614 | it("makes the appended number reach the ID when the name already contains that number", () => { |
| 615 | const name = "İzmir İzmit İznik İğdır İdil İspir İncir 2 Ö"; |
| 616 | const themes = resolveThemeLabelCollisions( |
| 617 | ["#1e1e2e", "#25203b"].map((canvas) => ({ |
| 618 | theme: parseThemeFile({ |
| 619 | version: THEME_FILE_VERSION, |
| 620 | id: "izmir-nightfall", |
| 621 | name, |
| 622 | appearance: "dark", |
| 623 | colors: { canvas }, |
| 624 | }), |
| 625 | })), |
| 626 | ); |
| 627 | expect(themes.map(({ label, id }) => [label, id])).toEqual([ |
| 628 | [name, "izmir-nightfall"], |
| 629 | [ |
| 630 | "İzmir İzmit İznik İğdır İdil İspir İncir 2", |
| 631 | "i-zmir-i-zmit-i-znik-i-d-r-i-dil-i-spir-i-ncir-2", |
| 632 | ], |
| 633 | ]); |
| 634 | }); |
| 635 | }); |