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 { describe, expect, it, vi } from "vite-plus/test";
import {
getCustomThemes,
getStoredCustomThemeCollection,
invalidateCustomThemes,
installCustomTheme,
parseThemeFile,
removeCustomTheme,
removeCustomThemes,
replaceCustomThemeCollection,
subscribeToCustomThemes,
updateCustomTheme,
CUSTOM_THEMES_STORAGE_KEY,
THEME_FILE_VERSION,
} from "./themePalette";
import { canonical } from "./themePalette.test-support";
describe("custom theme library", () => {
it("invalidates cached themes when another tab clears localStorage", () => {
let storedThemes: string | null = JSON.stringify([
{
id: "ocean-dusk",
label: "Ocean dusk",
appearance: "dark",
colors: { canvas: "#07152f" },
},
]);
let storageHandler: ((event: StorageEvent) => void) | undefined;
vi.stubGlobal("window", {
addEventListener: (type: string, listener: (event: StorageEvent) => void) => {
if (type === "storage") storageHandler = listener;
},
removeEventListener: vi.fn(),
localStorage: {
getItem: (key: string) => (key === CUSTOM_THEMES_STORAGE_KEY ? storedThemes : null),
},
});
invalidateCustomThemes();
expect(getCustomThemes()).toHaveLength(1);
const listener = vi.fn();
const unsubscribe = subscribeToCustomThemes(listener);
storedThemes = null;
storageHandler?.({ key: null } as StorageEvent);
expect(listener).toHaveBeenCalledTimes(1);
expect(getCustomThemes()).toEqual([]);
unsubscribe();
invalidateCustomThemes();
vi.unstubAllGlobals();
});
it("preserves valid imported-theme collections and drops malformed metadata", () => {
vi.stubGlobal("window", {
localStorage: {
getItem: (key: string) =>
key === CUSTOM_THEMES_STORAGE_KEY
? JSON.stringify([
{
id: "github-dark",
label: "GitHub Dark",
appearance: "dark",
colors: { canvas: "#0d1117" },
collection: { id: "open-vsx:github.github-vscode-theme", label: "GitHub Theme" },
},
{
id: "github-light",
label: "GitHub Light",
appearance: "light",
colors: { canvas: "#ffffff" },
collection: { id: "bad collection id", label: "GitHub Theme" },
},
])
: null,
},
});
invalidateCustomThemes();
expect(getCustomThemes()).toMatchObject([
{ collection: { id: "open-vsx:github.github-vscode-theme", label: "GitHub Theme" } },
{ id: "github-light" },
]);
expect(getCustomThemes()[1]).not.toHaveProperty("collection");
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("atomically replaces an imported collection and removes stale variants", () => {
const collection = { id: "open-vsx:demo.theme", label: "Demo Theme" };
const personalTheme = {
id: "personal",
label: "Personal",
appearance: "dark",
colors: { canvas: "#111111", futureRole: "hsl(10 20% 30%)" },
futureMetadata: { version: 2 },
};
const stored = new Map<string, string>([
[
CUSTOM_THEMES_STORAGE_KEY,
JSON.stringify([
personalTheme,
{
id: "old-light",
label: "Old Light",
appearance: "light",
colors: { canvas: "#ffffff" },
collection,
},
{
id: "removed-dark",
label: "Removed Dark",
appearance: "dark",
colors: { canvas: "#000000" },
collection,
},
]),
],
]);
const setItem = vi.fn((key: string, value: string) => stored.set(key, value));
vi.stubGlobal("window", {
localStorage: {
getItem: (key: string) => stored.get(key) ?? null,
setItem,
removeItem: () => {},
},
});
invalidateCustomThemes();
const expectedCollection = getStoredCustomThemeCollection(collection.id);
getCustomThemes();
const concurrentlyAddedTheme = {
id: "other-tab",
label: "Other Tab",
appearance: "dark",
colors: { canvas: "#222222" },
};
stored.set(
CUSTOM_THEMES_STORAGE_KEY,
JSON.stringify([
...JSON.parse(stored.get(CUSTOM_THEMES_STORAGE_KEY) ?? "[]"),
concurrentlyAddedTheme,
]),
);
const replacement = [
{
...parseThemeFile({
version: THEME_FILE_VERSION,
id: "old-light",
name: "New Light",
appearance: "light",
colors: { canvas: "#fafafa" },
}),
collection,
},
{
...parseThemeFile({
version: THEME_FILE_VERSION,
id: "new-dark",
name: "New Dark",
appearance: "dark",
colors: { canvas: "#101010" },
}),
collection,
},
];
expect(
replaceCustomThemeCollection(collection.id, replacement, { expectedCollection }),
).toEqual(replacement);
expect(getCustomThemes().map((theme) => theme.id)).toEqual([
"personal",
"old-light",
"new-dark",
"other-tab",
]);
expect(setItem).toHaveBeenCalledTimes(1);
expect(JSON.parse(stored.get(CUSTOM_THEMES_STORAGE_KEY) ?? "[]")[0]).toEqual(personalTheme);
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("replaces collection entries even when their stored collection label is malformed", () => {
const collection = { id: "open-vsx:demo.theme", label: "Demo Theme" };
const stored = new Map<string, string>([
[
CUSTOM_THEMES_STORAGE_KEY,
JSON.stringify([
{
id: "old-light",
label: "Old Light",
appearance: "light",
colors: { canvas: "#ffffff" },
collection: { id: collection.id, label: 42 },
},
]),
],
]);
vi.stubGlobal("window", {
localStorage: {
getItem: (key: string) => stored.get(key) ?? null,
setItem: (key: string, value: string) => stored.set(key, value),
removeItem: () => {},
},
});
invalidateCustomThemes();
const replacement = {
...parseThemeFile({
version: THEME_FILE_VERSION,
id: "old-light",
name: "New Light",
appearance: "light",
colors: { canvas: "#fafafa" },
}),
collection,
};
expect(replaceCustomThemeCollection(collection.id, [replacement])).toEqual([replacement]);
expect(getCustomThemes()).toEqual([replacement]);
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("canonicalizes explicit writes without migrating untouched themes", () => {
const stored = new Map<string, string>();
const untouchedTheme = {
id: "legacy",
label: "Legacy",
appearance: "dark",
colors: { accent: "#5b6cff", futureRole: "hsl(10 20% 30%)" },
futureMetadata: { version: 2 },
};
stored.set(CUSTOM_THEMES_STORAGE_KEY, JSON.stringify([untouchedTheme]));
vi.stubGlobal("window", {
localStorage: {
getItem: (key: string) => stored.get(key) ?? null,
setItem: (key: string, value: string) => stored.set(key, value),
removeItem: () => {},
},
});
invalidateCustomThemes();
const createdTheme = installCustomTheme(
parseThemeFile({
version: THEME_FILE_VERSION,
id: "aurora",
name: "Aurora",
appearance: "light",
colors: { canvas: "#f8fbff", accent: "#5b6cff" },
sidebarArtwork: true,
}),
);
const updatedTheme = updateCustomTheme({
...createdTheme,
label: "Aurora Night",
colors: { ...createdTheme.colors, accent: "hsl(263 70% 58%)" },
});
expect(updatedTheme).toMatchObject({
id: "aurora",
label: "Aurora Night",
colors: { accent: canonical("hsl(263 70% 58%)") },
});
expect(updatedTheme).not.toHaveProperty("sidebarArtwork");
const storedThemes = JSON.parse(stored.get(CUSTOM_THEMES_STORAGE_KEY) ?? "[]");
expect(storedThemes[0]).toEqual(untouchedTheme);
expect(storedThemes[1]).toMatchObject({
id: "aurora",
label: "Aurora Night",
colors: { accent: canonical("hsl(263 70% 58%)") },
});
expect(storedThemes[1]).not.toHaveProperty("sidebarArtwork");
invalidateCustomThemes();
expect(getCustomThemes().find((theme) => theme.id === "aurora")).toMatchObject({
id: "aurora",
colors: { accent: canonical("hsl(263 70% 58%)") },
});
removeCustomTheme("aurora");
expect(JSON.parse(stored.get(CUSTOM_THEMES_STORAGE_KEY) ?? "[]")).toEqual([untouchedTheme]);
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("removes multiple custom themes atomically while preserving unrelated entries", () => {
const collection = { id: "open-vsx:demo.theme", label: "Demo Theme" };
const personalTheme = {
id: "personal",
label: "Personal",
appearance: "dark",
colors: { canvas: "#111111", futureRole: "hsl(10 20% 30%)" },
futureMetadata: { version: 2 },
};
const stored = new Map<string, string>([
[
CUSTOM_THEMES_STORAGE_KEY,
JSON.stringify([
personalTheme,
{
id: "demo-light",
label: "Demo Light",
appearance: "light",
colors: { canvas: "#ffffff" },
collection,
},
{
id: "demo-dark",
label: "Demo Dark",
appearance: "dark",
colors: { canvas: "#000000" },
collection,
},
]),
],
]);
const setItem = vi.fn((key: string, value: string) => stored.set(key, value));
vi.stubGlobal("window", {
localStorage: {
getItem: (key: string) => stored.get(key) ?? null,
setItem,
removeItem: () => {},
},
});
invalidateCustomThemes();
removeCustomThemes(["demo-light", "demo-dark"]);
expect(setItem).toHaveBeenCalledOnce();
expect(getCustomThemes()).toEqual([expect.objectContaining({ id: "personal" })]);
expect(JSON.parse(stored.get(CUSTOM_THEMES_STORAGE_KEY) ?? "[]")).toEqual([personalTheme]);
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("writes from the cached raw snapshot without risking a destructive reread", () => {
const legacyTheme = {
id: "legacy",
label: "Legacy",
appearance: "dark",
colors: { accent: "#5b6cff" },
futureMetadata: true,
};
let storedThemes = JSON.stringify([legacyTheme]);
let readCount = 0;
const setItem = vi.fn((_key: string, value: string) => {
storedThemes = value;
});
vi.stubGlobal("window", {
localStorage: {
getItem: () => {
readCount += 1;
if (readCount > 1) throw new Error("transient read failure");
return storedThemes;
},
setItem,
removeItem: () => {},
},
});
invalidateCustomThemes();
expect(getCustomThemes()).toHaveLength(1);
installCustomTheme(
parseThemeFile({
version: THEME_FILE_VERSION,
id: "aurora",
name: "Aurora",
appearance: "light",
colors: { accent: "hsl(263 70% 58%)" },
}),
);
expect(readCount).toBe(1);
expect(setItem).toHaveBeenCalledOnce();
expect(JSON.parse(storedThemes)[0]).toEqual(legacyTheme);
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("refuses to overwrite a theme library that could not be read", () => {
const setItem = vi.fn();
vi.stubGlobal("window", {
localStorage: {
getItem: () => {
throw new Error("storage unavailable");
},
setItem,
removeItem: () => {},
},
});
invalidateCustomThemes();
expect(getCustomThemes()).toEqual([]);
expect(() =>
installCustomTheme(
parseThemeFile({
version: THEME_FILE_VERSION,
id: "aurora",
name: "Aurora",
appearance: "light",
colors: { accent: "#5b6cff" },
}),
),
).toThrow(`Failed to read the theme library from ${CUSTOM_THEMES_STORAGE_KEY}.`);
expect(setItem).not.toHaveBeenCalled();
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("rejects malformed stored entries that reuse an installed theme id", () => {
const storedThemes = JSON.stringify([{ id: "aurora", malformed: true }]);
const setItem = vi.fn();
vi.stubGlobal("window", {
localStorage: {
getItem: () => storedThemes,
setItem,
removeItem: () => {},
},
});
invalidateCustomThemes();
expect(() =>
installCustomTheme(
parseThemeFile({
version: THEME_FILE_VERSION,
id: "aurora",
name: "Aurora",
appearance: "light",
colors: { accent: "#5b6cff" },
}),
),
).toThrow('A theme named "Aurora" is already installed.');
expect(setItem).not.toHaveBeenCalled();
vi.unstubAllGlobals();
invalidateCustomThemes();
});
it("collapses duplicate raw entries when their theme is explicitly updated", () => {
const stored = new Map<string, string>();
const theme = {
id: "aurora",
label: "Aurora",
appearance: "light",
colors: { accent: "#5b6cff" },
};
const untouchedTheme = { id: "future", malformed: true, metadata: { version: 2 } };
stored.set(
CUSTOM_THEMES_STORAGE_KEY,
JSON.stringify([theme, { id: "aurora", malformed: true }, untouchedTheme]),
);
vi.stubGlobal("window", {
localStorage: {
getItem: (key: string) => stored.get(key) ?? null,
setItem: (key: string, value: string) => stored.set(key, value),
removeItem: () => {},
},
});
invalidateCustomThemes();
const installedTheme = getCustomThemes()[0]!;
updateCustomTheme({
...installedTheme,
label: "Aurora Night",
colors: { ...installedTheme.colors, accent: "hsl(263 70% 58%)" },
});
const updatedLibrary = JSON.parse(stored.get(CUSTOM_THEMES_STORAGE_KEY) ?? "[]");
expect(updatedLibrary.filter((entry: { id?: string }) => entry.id === "aurora")).toHaveLength(
1,
);
expect(updatedLibrary[0]).toMatchObject({
id: "aurora",
label: "Aurora Night",
colors: { accent: canonical("hsl(263 70% 58%)") },
});
expect(updatedLibrary[1]).toEqual(untouchedTheme);
vi.unstubAllGlobals();
invalidateCustomThemes();
});
});