The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(plugins): import IntelliJ theme plugins (#1184)
Lee Dong Geon6dec1252dbd1
diff --git a/Cargo.lock b/Cargo.lockindex 62c74e7e4..a9bce3786 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4272,6 +4272,7 @@ dependencies = ["ide-workspace","ignore","parking_lot",+ "quick-xml","regex-syntax","reqwest","rustix",diff --git a/crates/ide-host/Cargo.toml b/crates/ide-host/Cargo.tomlindex cdb17dcf4..70c843e77 100644--- a/crates/ide-host/Cargo.toml+++ b/crates/ide-host/Cargo.toml@@ -59,12 +59,13 @@ dunce.workspace = truedirs.workspace = trueuuid.workspace = truetempfile.workspace = true+zip.workspace = true+quick-xml = "0.42"[dev-dependencies]ide-ssh = { workspace = true, features = ["testing"] }tokio = { workspace = true, features = ["rt-multi-thread", "macros", "io-util", "test-util"] }criterion = { version = "0.5", default-features = false }-zip.workspace = true[target.'cfg(unix)'.dependencies]rustix = { version = "1.1", features = ["fs", "process"] }diff --git a/crates/ide-host/src/plugins/intellij.rs b/crates/ide-host/src/plugins/intellij.rsnew file mode 100644index 000000000..3ccc62fa5--- /dev/null+++ b/crates/ide-host/src/plugins/intellij.rs@@ -0,0 +1,874 @@+//! IntelliJ theme plugins, read for import as OpenIDEA theme plugins: a+//! Marketplace download (a `.jar`, or a `.zip` holding the plugin's+//! `lib/*.jar`), an installed plugin's folder or a loose `.theme.json`; and the+//! theme plugins of the JetBrains IDEs on this machine, with the theme each IDE+//! is set to (`options/laf.xml`).+//!+//! Nothing is converted here: the UI maps IntelliJ keys onto design tokens+//! (`src/features/plugins/intellijTheme.ts`, shared with `pnpm+//! theme:import-intellij`) and [`super::PluginHost::stage_package`] writes the+//! result for the install page, which validates it like any package.++use ide_core::{IdeError, IdeResult, IpcPath};+use quick_xml::{Reader, XmlVersion, events::Event};+use serde::{Deserialize, Serialize};+use specta::Type;+use std::ffi::OsString;+use std::io::{Cursor, Read, Seek};+use std::path::{Path, PathBuf};++/// A descriptor, theme or editor scheme larger than this is not one.+const MAX_FILE: u64 = 4 << 20;+/// A plugin jar read into memory from a Marketplace zip.+const MAX_JAR: u64 = 64 << 20;+/// Jars of one plugin looked into.+const MAX_JARS: usize = 64;+/// All the jars read into memory from one Marketplace zip.+const MAX_NESTED: u64 = 256 << 20;+/// Descriptors read for one plugin: `plugin.xml` and those it includes.+const MAX_DESCRIPTORS: usize = 64;+const PLUGIN_XML: &str = "META-INF/plugin.xml";++/// A theme plugin's themes, as read from its files.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct IntellijThemeSource {+ /// The plugin's `<name>`, or the theme's for a loose file.+ pub name: String,+ pub plugin_id: Option<String>,+ pub version: Option<String>,+ pub vendor: Option<String>,+ pub themes: Vec<IntellijThemeFile>,+}++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct IntellijThemeFile {+ /// The `themeProvider` id (what `laf.xml` names), or the file name without `.theme.json`.+ pub id: String,+ /// The `.theme.json`, comments removed.+ pub theme: String,+ /// The editor scheme (`.icls` XML) its `editorScheme` names, when the plugin has it.+ pub editor_scheme: Option<String>,+}++/// A theme of a plugin installed in a JetBrains IDE.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct InstalledIntellijTheme {+ /// The IDE and its version: `IntelliJ IDEA 2025.2`.+ pub ide: String,+ /// The plugin's name.+ pub plugin: String,+ /// What to import: the plugin's folder or jar.+ pub path: IpcPath,+ pub theme_id: String,+ pub theme_name: String,+ pub dark: bool,+ /// The IDE is set to this theme.+ pub active: bool,+}++/// Reads the themes of an IntelliJ theme plugin (a `.jar`, a Marketplace+/// `.zip`, an installed plugin's folder) or of a `.theme.json`.+pub fn read_source(path: &Path) -> IdeResult<IntellijThemeSource> {+ read(path).map_err(IdeError::invalid)+}++/// The theme plugins of the JetBrains IDEs (and Android Studio) of this user,+/// the themes their IDEs are set to first.+pub fn installed_themes() -> Vec<InstalledIntellijTheme> {+ let Some(home) = dirs::home_dir() else { return Vec::new() };+ let layout = if cfg!(target_os = "macos") {+ Layout::Mac+ } else if cfg!(windows) {+ Layout::Windows+ } else {+ Layout::Xdg+ };+ find_installed(&ide_dirs(layout, &home, |key| std::env::var_os(key)))+}++fn read(path: &Path) -> Result<IntellijThemeSource, String> {+ if path.extension().is_some_and(|e| e.eq_ignore_ascii_case("json")) {+ return loose_theme(path);+ }+ let mut jars = plugin_jars(path)?;+ let plugin = descriptor(&mut jars)?;+ let shown = || path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();+ if plugin.themes.is_empty() {+ return Err(format!("{} is not a theme plugin: its plugin.xml declares no themeProvider", shown()));+ }+ let mut themes = Vec::new();+ let mut problem = None;+ for (id, theme_path) in &plugin.themes {+ match plugin_theme(&mut jars, id, theme_path) {+ Ok(theme) => themes.push(theme),+ Err(e) => problem = problem.or(Some(e)),+ }+ }+ if themes.is_empty() {+ return Err(problem.unwrap_or_else(|| format!("{} has no readable theme", shown())));+ }+ Ok(IntellijThemeSource {+ name: plugin.name.unwrap_or_else(shown),+ plugin_id: plugin.id,+ version: plugin.version,+ vendor: plugin.vendor,+ themes,+ })+}++fn plugin_theme(jars: &mut [Jar], id: &str, path: &str) -> Result<IntellijThemeFile, String> {+ let bytes = find(jars, entry_name(path), MAX_FILE)?.ok_or_else(|| format!("{path} is missing from the plugin"))?;+ let (theme, fields) = theme_json(&bytes).map_err(|e| format!("{path}: {e}"))?;+ let editor_scheme = match string_field(&fields, "editorScheme") {+ Some(scheme) => find(jars, entry_name(scheme), MAX_FILE)?.map(|b| text(&b)),+ None => None,+ };+ Ok(IntellijThemeFile { id: id.to_owned(), theme, editor_scheme })+}++/// A `.theme.json` with the editor scheme beside it (its `editorScheme` names a path in the plugin's jar).+fn loose_theme(path: &Path) -> Result<IntellijThemeSource, String> {+ let (theme, fields) = theme_json(&read_file(path)?).map_err(|e| format!("{}: {e}", path.display()))?;+ // Any JSON object parses: an IntelliJ theme has UI colours or an editor scheme.+ let scheme_ref = string_field(&fields, "editorScheme");+ if !fields.get("ui").is_some_and(serde_json::Value::is_object) && scheme_ref.is_none() {+ return Err(format!("{} is not an IntelliJ theme: it has no \"ui\" or \"editorScheme\"", path.display()));+ }+ let editor_scheme = scheme_ref+ .and_then(|p| Path::new(p).file_name().map(|n| path.with_file_name(n)))+ .filter(|p| p.is_file())+ .map(|p| read_file(&p).map(|b| text(&b)))+ .transpose()?;+ let file = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();+ let id = file.strip_suffix(".theme.json").or_else(|| file.strip_suffix(".json")).unwrap_or(&file).to_owned();+ Ok(IntellijThemeSource {+ name: string_field(&fields, "name").map_or_else(|| id.clone(), str::to_owned),+ plugin_id: None,+ version: None,+ vendor: string_field(&fields, "author").map(str::to_owned),+ themes: vec![IntellijThemeFile { id, theme, editor_scheme }],+ })+}++type JsonObject = serde_json::Map<String, serde_json::Value>;++/// The theme JSON, comments removed, and its fields, if it is an object.+fn theme_json(bytes: &[u8]) -> Result<(String, JsonObject), String> {+ let json = super::theme::strip_json_comments(&text(bytes));+ match serde_json::from_str::<serde_json::Value>(&json) {+ Ok(serde_json::Value::Object(fields)) => Ok((json, fields)),+ Ok(_) => Err("not a theme: expected a JSON object".into()),+ Err(e) => Err(format!("invalid theme JSON: {e}")),+ }+}++fn string_field<'a>(fields: &'a JsonObject, key: &str) -> Option<&'a str> {+ fields.get(key)?.as_str().filter(|s| !s.trim().is_empty())+}++/// `/themes/x.theme.json` → `themes/x.theme.json`.+fn entry_name(path: &str) -> &str {+ path.trim().trim_start_matches('/')+}++fn text(bytes: &[u8]) -> String {+ let bytes = bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes);+ String::from_utf8_lossy(bytes).into_owned()+}++fn read_file(path: &Path) -> Result<Vec<u8>, String> {+ let shown = |e: std::io::Error| format!("{}: {e}", path.display());+ let file = std::fs::File::open(path).map_err(shown)?;+ let mut buf = Vec::new();+ file.take(MAX_FILE + 1).read_to_end(&mut buf).map_err(shown)?;+ if buf.len() as u64 > MAX_FILE {+ return Err(format!("{} is too large for a theme", path.display()));+ }+ Ok(buf)+}++trait ReadSeek: Read + Seek {}+impl<T: Read + Seek> ReadSeek for T {}+type Jar = zip::ZipArchive<Box<dyn ReadSeek>>;++fn open_jar(path: &Path) -> Result<Jar, String> {+ let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?;+ let reader: Box<dyn ReadSeek> = Box::new(std::io::BufReader::new(file));+ zip::ZipArchive::new(reader).map_err(|e| format!("{} is not a jar or zip file ({e})", path.display()))+}++/// The jars of the plugin at `path`: a jar, a Marketplace zip (`<plugin>/lib/*.jar`)+/// or an installed plugin's folder (`lib/*.jar`).+fn plugin_jars(path: &Path) -> Result<Vec<Jar>, String> {+ let not_plugin = || format!("{} is not an IntelliJ plugin: no {PLUGIN_XML} and no lib/*.jar", path.display());+ if path.is_dir() {+ let mut found: Vec<PathBuf> = [path.join("lib"), path.join("lib").join("modules")]+ .iter()+ .flat_map(|dir| std::fs::read_dir(dir).into_iter().flatten().flatten())+ .map(|e| e.path())+ .filter(|p| p.is_file() && is_jar(p))+ .collect();+ found.sort();+ let jars: Vec<Jar> = found.iter().take(MAX_JARS).filter_map(|p| open_jar(p).ok()).collect();+ return if jars.is_empty() { Err(not_plugin()) } else { Ok(jars) };+ }+ let mut archive = open_jar(path)?;+ if archive.index_for_name(PLUGIN_XML).is_some() {+ return Ok(vec![archive]);+ }+ let jars = nested_jars(&mut archive, MAX_JAR, MAX_NESTED);+ if jars.is_empty() { Err(not_plugin()) } else { Ok(jars) }+}++/// The `lib` jars of a Marketplace zip, smallest first (a theme's own jar is small)+/// while they fit `max_total`; library jars too large or not jars at all are skipped.+fn nested_jars(archive: &mut Jar, max_jar: u64, max_total: u64) -> Vec<Jar> {+ let mut nested: Vec<(u64, String)> = entry_names(archive)+ .into_iter()+ .filter(|n| is_lib_jar(n))+ .filter_map(|n| Some((archive.by_name(&n).ok()?.size(), n)))+ .filter(|(size, _)| *size <= max_jar)+ .collect();+ nested.sort();+ let (mut jars, mut loaded) = (Vec::new(), 0u64);+ for (size, name) in nested.into_iter().take(MAX_JARS) {+ if loaded.saturating_add(size) > max_total {+ break;+ }+ let Ok(Some(bytes)) = read_entry(archive, &name, max_jar) else { continue };+ loaded += size;+ let reader: Box<dyn ReadSeek> = Box::new(Cursor::new(bytes));+ if let Ok(jar) = zip::ZipArchive::new(reader) {+ jars.push(jar);+ }+ }+ jars+}++fn entry_names(jar: &Jar) -> Vec<String> {+ jar.file_names().filter_map(Result::ok).map(|n| n.into_owned()).collect()+}++fn is_jar(path: &Path) -> bool {+ path.extension().is_some_and(|e| e.eq_ignore_ascii_case("jar"))+}++/// `lib/x.jar`, `<plugin>/lib/x.jar` or `<plugin>/lib/modules/x.jar` in a Marketplace zip.+fn is_lib_jar(name: &str) -> bool {+ let parts: Vec<&str> = name.split('/').collect();+ let n = parts.len();+ name.to_ascii_lowercase().ends_with(".jar")+ && (2..=4).contains(&n)+ && (parts[n - 2] == "lib" || (n >= 3 && parts[n - 2] == "modules" && parts[n - 3] == "lib"))+}++fn read_entry(jar: &mut Jar, name: &str, max: u64) -> Result<Option<Vec<u8>>, String> {+ let Ok(file) = jar.by_name(name) else { return Ok(None) };+ if file.is_dir() {+ return Ok(None);+ }+ if file.size() > max {+ return Err(format!("{name} is too large"));+ }+ let mut buf = Vec::with_capacity(file.size() as usize);+ file.take(max.saturating_add(1)).read_to_end(&mut buf).map_err(|e| format!("{name}: {e}"))?;+ if buf.len() as u64 > max {+ return Err(format!("{name} is too large"));+ }+ Ok(Some(buf))+}++fn find(jars: &mut [Jar], name: &str, max: u64) -> Result<Option<Vec<u8>>, String> {+ for jar in jars.iter_mut() {+ if let Some(bytes) = read_entry(jar, name, max)? {+ return Ok(Some(bytes));+ }+ }+ Ok(None)+}++/// What the plugin's descriptors say: `<idea-plugin>`'s `id`, `name`, `version`,+/// `vendor`, and its `themeProvider`s (id, path in the jar).+#[derive(Debug, Default, PartialEq)]+struct Descriptor {+ id: Option<String>,+ name: Option<String>,+ version: Option<String>,+ vendor: Option<String>,+ themes: Vec<(String, String)>,+}++/// Reads `META-INF/plugin.xml` and the descriptors it includes (`<xi:include href>`), in any jar.+fn descriptor(jars: &mut [Jar]) -> Result<Descriptor, String> {+ let main = find(jars, PLUGIN_XML, MAX_FILE)+ .ok()+ .flatten()+ .ok_or_else(|| format!("not an IntelliJ plugin: no {PLUGIN_XML}"))?;+ let mut out = Descriptor::default();+ let mut includes = Vec::new();+ parse_descriptor(&text(&main), true, &mut out, &mut includes).map_err(|e| format!("{PLUGIN_XML}: {e}"))?;+ let mut read = std::collections::HashSet::from([PLUGIN_XML.to_owned()]);+ while let Some(href) = includes.pop() {+ let name = include_entry(&href);+ if read.len() >= MAX_DESCRIPTORS || !read.insert(name.clone()) {+ continue;+ }+ let Ok(Some(bytes)) = find(jars, &name, MAX_FILE) else { continue };+ let _ = parse_descriptor(&text(&bytes), false, &mut out, &mut includes);+ }+ let mut seen = std::collections::HashSet::new();+ out.themes.retain(|(id, _)| seen.insert(id.clone()));+ Ok(out)+}++/// An `<xi:include href>` as a jar entry: `/META-INF/x.xml` from the jar's root, `x.xml` beside plugin.xml.+fn include_entry(href: &str) -> String {+ let href = href.trim();+ href.strip_prefix('/').map_or_else(|| format!("META-INF/{href}"), str::to_owned)+}++fn parse_descriptor(xml: &str, main: bool, out: &mut Descriptor, includes: &mut Vec<String>) -> Result<(), String> {+ let mut reader = Reader::from_str(xml);+ let mut stack: Vec<String> = Vec::new();+ let mut text = String::new();+ loop {+ let event = reader.read_event().map_err(|e| e.to_string())?;+ match event {+ Event::Start(ref tag) | Event::Empty(ref tag) => {+ let name = tag.local_name().as_ref().to_owned();+ if name == "include" {+ let href = tag.attributes().flatten().find(|a| a.key.local_name().as_ref() == "href");+ if let Some(href) = href.and_then(|a| a.normalized_value(XmlVersion::Implicit1_0).ok()) {+ includes.push(href.into_owned());+ }+ }+ if name == "themeProvider" {+ let (mut id, mut path) = (None, None);+ for a in tag.attributes() {+ let a = a.map_err(|e| e.to_string())?;+ let value = a.normalized_value(XmlVersion::Implicit1_0).map_err(|e| e.to_string())?;+ match a.key.local_name().as_ref() {+ "id" => id = Some(value.trim().to_owned()),+ "path" => path = Some(value.trim().to_owned()),+ _ => {}+ }+ }+ if let (Some(id), Some(path)) = (id, path)+ && !id.is_empty()+ && !path.is_empty()+ {+ out.themes.push((id, path));+ }+ }+ if matches!(event, Event::Start(_)) {+ stack.push(name);+ text.clear();+ }+ }+ Event::Text(t) => text.push_str(&t.xml_content(XmlVersion::Implicit1_0)),+ Event::CData(t) => text.push_str(t.as_ref()),+ Event::GeneralRef(r) => {+ let name = r.as_ref();+ let escaped = format!("&{name};");+ text.push_str(&quick_xml::escape::unescape(&escaped).map_err(|e| e.to_string())?);+ }+ Event::End(_) => {+ let name = stack.pop().ok_or("unbalanced element")?;+ // Direct children of <idea-plugin>.+ if main && stack.len() == 1 && stack[0] == "idea-plugin" {+ let value = text.trim();+ let slot = match name.as_str() {+ "id" => Some(&mut out.id),+ "name" => Some(&mut out.name),+ "version" => Some(&mut out.version),+ "vendor" => Some(&mut out.vendor),+ _ => None,+ };+ if let Some(slot) = slot+ && slot.is_none()+ && !value.is_empty()+ {+ *slot = Some(value.to_owned());+ }+ }+ text.clear();+ }+ Event::Eof => return if stack.is_empty() { Ok(()) } else { Err("unclosed element".into()) },+ _ => {}+ }+ }+}++/// Where an OS keeps the IDEs' settings and plugins.+#[derive(Clone, Copy, Debug)]+enum Layout {+ /// `~/Library/Application Support/<vendor>/<IDE>`, plugins in its `plugins/`.+ Mac,+ /// `%APPDATA%\<vendor>\<IDE>`, plugins in its `plugins\`.+ Windows,+ /// `$XDG_CONFIG_HOME/<vendor>/<IDE>`, plugins in `$XDG_DATA_HOME/<vendor>/<IDE>`.+ Xdg,+}++#[derive(Debug, PartialEq)]+struct IdeDir {+ label: String,+ product: String,+ version: (u32, u32),+ config: PathBuf,+ plugins: PathBuf,+}++/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest first.+fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>) -> Vec<IdeDir> {+ let var = |key: &str| env(key).filter(|v| !v.is_empty()).map(PathBuf::from);+ let (config_root, data_root) = match layout {+ Layout::Mac => {+ let root = home.join("Library").join("Application Support");+ (root.clone(), root)+ }+ Layout::Windows => {+ let root = var("APPDATA").unwrap_or_else(|| home.join("AppData").join("Roaming"));+ (root.clone(), root)+ }+ Layout::Xdg => (+ var("XDG_CONFIG_HOME").unwrap_or_else(|| home.join(".config")),+ var("XDG_DATA_HOME").unwrap_or_else(|| home.join(".local").join("share")),+ ),+ };+ let mut out = Vec::new();+ for vendor in ["JetBrains", "Google"] {+ for entry in std::fs::read_dir(config_root.join(vendor)).into_iter().flatten().flatten() {+ let name = entry.file_name().to_string_lossy().into_owned();+ let Some((product, version, shown)) = product_dir(&name) else { continue };+ let config = entry.path();+ if !config.is_dir() {+ continue;+ }+ let plugins = match layout {+ Layout::Xdg => data_root.join(vendor).join(&name),+ Layout::Mac | Layout::Windows => config.join("plugins"),+ };+ out.push(IdeDir {+ label: format!("{} {shown}", product_label(product)),+ product: product.to_owned(),+ version,+ config,+ plugins,+ });+ }+ }+ out.sort_by(|a, b| b.version.cmp(&a.version).then_with(|| a.label.cmp(&b.label)));+ out+}++/// `IntelliJIdea2025.2` → (`IntelliJIdea`, (2025, 2), `2025.2`).+fn product_dir(name: &str) -> Option<(&str, (u32, u32), &str)> {+ let at = name.find(|c: char| c.is_ascii_digit())?;+ let (product, version) = name.split_at(at);+ if product.is_empty() || !product.chars().all(|c| c.is_ascii_alphabetic()) {+ return None;+ }+ let (year, minor) = version.split_once('.')?;+ let ok = |s: &str| !s.is_empty() && s.len() <= 4 && s.chars().all(|c| c.is_ascii_digit());+ if year.len() != 4 || !ok(year) || !ok(minor) {+ return None;+ }+ Some((product, (year.parse().ok()?, minor.parse().ok()?), version))+}++fn product_label(product: &str) -> &str {+ match product {+ "IntelliJIdea" => "IntelliJ IDEA",+ "IdeaIC" => "IntelliJ IDEA Community Edition",+ "PyCharmCE" => "PyCharm Community Edition",+ "AndroidStudio" => "Android Studio",+ "AndroidStudioPreview" => "Android Studio Preview",+ other => other,+ }+}++/// The theme ids `options/laf.xml` selects: the current one, and with "Sync with OS" the preferred light and dark.+fn active_theme_ids(config: &Path) -> Vec<String> {+ let Ok(bytes) = read_file(&config.join("options").join("laf.xml")) else { return Vec::new() };+ let xml = text(&bytes);+ let mut reader = Reader::from_str(&xml);+ let (mut ids, mut preferred, mut autodetect) = (Vec::new(), Vec::new(), false);+ loop {+ match reader.read_event() {+ Ok(Event::Start(tag) | Event::Empty(tag)) => {+ let attr = |key: &str| {+ tag.attributes()+ .flatten()+ .find(|a| a.key.as_ref() == key)+ .and_then(|a| a.normalized_value(XmlVersion::Implicit1_0).ok().map(|v| v.trim().to_owned()))+ };+ match tag.local_name().as_ref() {+ "component" if attr("name").as_deref() == Some("LafManager") => {+ autodetect = attr("autodetect").as_deref() == Some("true");+ }+ "laf" => ids.extend(attr("themeId")),+ "preferred-light-laf" | "preferred-dark-laf" => preferred.extend(attr("themeId")),+ _ => {}+ }+ }+ Ok(Event::Eof) | Err(_) => break,+ _ => {}+ }+ }+ if autodetect {+ ids.extend(preferred);+ }+ ids.retain(|id| !id.is_empty());+ ids+}++fn find_installed(ides: &[IdeDir]) -> Vec<InstalledIntellijTheme> {+ let mut out = Vec::new();+ for ide in ides {+ let active = active_theme_ids(&ide.config);+ let mut plugins: Vec<PathBuf> = std::fs::read_dir(&ide.plugins)+ .into_iter()+ .flatten()+ .flatten()+ .map(|e| e.path())+ .filter(|p| p.is_dir() || (p.is_file() && is_jar(p)))+ .collect();+ plugins.sort();+ for plugin in plugins {+ let Ok(mut jars) = plugin_jars(&plugin) else { continue };+ let Ok(found) = descriptor(&mut jars) else { continue };+ for (id, path) in &found.themes {+ let Ok(Some(bytes)) = find(&mut jars, entry_name(path), MAX_FILE) else { continue };+ let Ok((_, fields)) = theme_json(&bytes) else { continue };+ let file = || plugin.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();+ out.push(InstalledIntellijTheme {+ ide: ide.label.clone(),+ plugin: found.name.clone().unwrap_or_else(file),+ path: plugin.clone().into(),+ theme_id: id.clone(),+ theme_name: string_field(&fields, "name").unwrap_or(id).to_owned(),+ dark: fields.get("dark").and_then(serde_json::Value::as_bool).unwrap_or(true),+ active: active.contains(id),+ });+ }+ }+ }+ // Stable: the IDEs' order (newest first) within each group.+ out.sort_by_key(|t| !t.active);+ out+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::io::Write;++ const PLUGIN: &str = r#"<idea-plugin>+ <id>com.example.deepsea</id>+ <name>Deep Sea & Friends</name>+ <version>2.3</version>+ <vendor email="[email protected]">Someone</vendor>+ <description><![CDATA[<b>Dark</b> themes]]></description>+ <depends>com.intellij.modules.platform</depends>+ <extensions defaultExtensionNs="com.intellij">+ <themeProvider id="deep-sea-id" path="/themes/DeepSea.theme.json"/>+ <themeProvider id="shallow-id" path="themes/Shallow.theme.json" />+ </extensions>+</idea-plugin>"#;++ const DEEP: &str = r##"{+ // comment+ "name": "Deep Sea",+ "dark": true,+ "editorScheme": "/themes/DeepSea.xml",+ "ui": { "*": { "background": "#101820" } }+}"##;+ const SHALLOW: &str = r#"{ "name": "Shallow", "dark": false, "ui": {} }"#;+ const SCHEME: &str = r#"<scheme name="Deep Sea" version="142" parent_scheme="Darcula"/>"#;++ fn jar_bytes(entries: &[(&str, &[u8])]) -> Vec<u8> {+ let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));+ for (name, data) in entries {+ zip.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();+ zip.write_all(data).unwrap();+ }+ zip.finish().unwrap().into_inner()+ }++ fn theme_jar() -> Vec<u8> {+ jar_bytes(&[+ ("META-INF/MANIFEST.MF", b"Manifest-Version: 1.0\n"),+ (PLUGIN_XML, PLUGIN.as_bytes()),+ ("themes/DeepSea.theme.json", DEEP.as_bytes()),+ ("themes/DeepSea.xml", SCHEME.as_bytes()),+ ("themes/Shallow.theme.json", SHALLOW.as_bytes()),+ ])+ }++ fn write(path: &Path, bytes: &[u8]) {+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();+ std::fs::write(path, bytes).unwrap();+ }++ fn expected_source() -> IntellijThemeSource {+ IntellijThemeSource {+ name: "Deep Sea & Friends".into(),+ plugin_id: Some("com.example.deepsea".into()),+ version: Some("2.3".into()),+ vendor: Some("Someone".into()),+ themes: vec![+ IntellijThemeFile {+ id: "deep-sea-id".into(),+ theme: super::super::theme::strip_json_comments(DEEP),+ editor_scheme: Some(SCHEME.into()),+ },+ IntellijThemeFile { id: "shallow-id".into(), theme: SHALLOW.into(), editor_scheme: None },+ ],+ }+ }++ #[test]+ fn reads_a_theme_jar_with_its_editor_scheme() {+ let tmp = tempfile::tempdir().unwrap();+ let jar = tmp.path().join("deep-sea.jar");+ write(&jar, &theme_jar());+ let source = read_source(&jar).unwrap();+ assert_eq!(source, expected_source());+ assert!(!source.themes[0].theme.contains("comment"));+ }++ #[test]+ fn reads_a_marketplace_zip_and_an_installed_folder() {+ let tmp = tempfile::tempdir().unwrap();+ let other = jar_bytes(&[("META-INF/MANIFEST.MF", b"x"), ("a/B.class", b"\xCA\xFE")]);+ let zip = tmp.path().join("DeepSea-2.3.zip");+ write(&zip, &jar_bytes(&[("DeepSea/lib/a-util.jar", &other), ("DeepSea/lib/deep-sea.jar", &theme_jar())]));+ assert_eq!(read_source(&zip).unwrap(), expected_source());++ let dir = tmp.path().join("plugins").join("DeepSea");+ write(&dir.join("lib").join("deep-sea.jar"), &theme_jar());+ write(&dir.join("lib").join("a-util.jar"), &other);+ assert_eq!(read_source(&dir).unwrap(), expected_source());+ }++ #[test]+ fn skips_library_jars_it_cannot_or_need_not_read() {+ let tmp = tempfile::tempdir().unwrap();+ // Stored, not deflated: as large in the zip as its content.+ let mut big = zip::ZipWriter::new(Cursor::new(Vec::new()));+ let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);+ big.start_file("lib/Data.class", stored).unwrap();+ big.write_all(&[b'x'; 8192]).unwrap();+ let big = big.finish().unwrap().into_inner();+ let zip = tmp.path().join("DeepSea.zip");+ write(+ &zip,+ &jar_bytes(&[+ ("DeepSea/lib/a-broken.jar", b"not a jar"),+ ("DeepSea/lib/b-big.jar", &big),+ ("DeepSea/lib/deep-sea.jar", &theme_jar()),+ ]),+ );+ assert_eq!(read_source(&zip).unwrap(), expected_source());++ // The broken jar is skipped; a jar over the size limit, or past the total+ // (smallest first), is not read, while the theme's small jar still is.+ let mut archive = open_jar(&zip).unwrap();+ let theme_len = theme_jar().len() as u64;+ assert_eq!(nested_jars(&mut archive, u64::MAX, u64::MAX).len(), 2);+ let one = nested_jars(&mut archive, theme_len + 64, u64::MAX);+ assert_eq!(one.len(), 1);+ assert!(one[0].index_for_name(PLUGIN_XML).is_some());+ assert_eq!(nested_jars(&mut archive, u64::MAX, theme_len + 64).len(), 1);+ assert!(nested_jars(&mut archive, 8, u64::MAX).is_empty());+ }++ #[test]+ fn reads_a_loose_theme_json_with_the_scheme_beside_it() {+ let tmp = tempfile::tempdir().unwrap();+ let theme = tmp.path().join("DeepSea.theme.json");+ write(&theme, DEEP.as_bytes());+ write(&tmp.path().join("DeepSea.xml"), SCHEME.as_bytes());+ let source = read_source(&theme).unwrap();+ assert_eq!(source.name, "Deep Sea");+ assert_eq!(source.themes.len(), 1);+ assert_eq!(source.themes[0].id, "DeepSea");+ assert_eq!(source.themes[0].editor_scheme.as_deref(), Some(SCHEME));++ std::fs::remove_file(tmp.path().join("DeepSea.xml")).unwrap();+ assert_eq!(read_source(&theme).unwrap().themes[0].editor_scheme, None);+ }++ #[test]+ fn says_what_is_wrong_with_other_files() {+ let tmp = tempfile::tempdir().unwrap();+ let not_zip = tmp.path().join("notes.jar");+ write(¬_zip, b"hello");+ assert!(read_source(¬_zip).unwrap_err().message.contains("not a jar or zip"));++ let other_plugin = tmp.path().join("tools.jar");+ let xml = "<idea-plugin><name>Tools</name><actions/></idea-plugin>";+ write(&other_plugin, &jar_bytes(&[(PLUGIN_XML, xml.as_bytes())]));+ assert!(read_source(&other_plugin).unwrap_err().message.contains("not a theme plugin"));++ let package = tmp.path().join("package.zip");+ write(&package, &jar_bytes(&[("plugin.toml", b"id = \"x\"")]));+ assert!(read_source(&package).unwrap_err().message.contains("not an IntelliJ plugin"));++ let other = tmp.path().join("package.json");+ write(&other, br#"{ "name": "app", "version": "1.0.0" }"#);+ assert!(read_source(&other).unwrap_err().message.contains("is not an IntelliJ theme"));++ let broken = tmp.path().join("broken.theme.json");+ write(&broken, b"{ \"name\": ");+ assert!(read_source(&broken).unwrap_err().message.contains("invalid theme JSON"));++ let missing = tmp.path().join("missing.jar");+ let xml = r#"<idea-plugin><name>M</name><themeProvider id="m" path="/m.theme.json"/></idea-plugin>"#;+ write(&missing, &jar_bytes(&[(PLUGIN_XML, xml.as_bytes())]));+ assert!(read_source(&missing).unwrap_err().message.contains("/m.theme.json is missing"));+ }++ #[test]+ fn finds_theme_providers_in_included_descriptors() {+ let tmp = tempfile::tempdir().unwrap();+ let jar = tmp.path().join("split.jar");+ let main = r#"<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude"><name>Split</name>+ <xi:include href="/META-INF/themes.xml"/></idea-plugin>"#;+ let part = r#"<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude"><extensions defaultExtensionNs="com.intellij">+ <themeProvider id="s" path="/s.theme.json"/></extensions><name>Not this</name>+ <xi:include href="more.xml"/><xi:include href="/META-INF/themes.xml"/></idea-plugin>"#;+ let more = r#"<idea-plugin><themeProvider id="m" path="/m.theme.json"/></idea-plugin>"#;+ let unrelated = r#"<idea-plugin><themeProvider id="x" path="/x.theme.json"/></idea-plugin>"#;+ write(+ &jar,+ &jar_bytes(&[+ ("META-INF/themes.xml", part.as_bytes()),+ ("META-INF/more.xml", more.as_bytes()),+ ("META-INF/unrelated.xml", unrelated.as_bytes()),+ (PLUGIN_XML, main.as_bytes()),+ ("s.theme.json", br#"{"name":"S"}"#),+ ("m.theme.json", br#"{"name":"M"}"#),+ ("x.theme.json", br#"{"name":"X"}"#),+ ]),+ );+ let source = read_source(&jar).unwrap();+ assert_eq!(source.name, "Split");+ // Only what plugin.xml includes (relative or from the root, once each) counts.+ assert_eq!(source.themes.iter().map(|t| t.id.as_str()).collect::<Vec<_>>(), ["s", "m"]);+ }++ #[test]+ fn parses_ide_folder_names() {+ assert_eq!(product_dir("IntelliJIdea2025.2"), Some(("IntelliJIdea", (2025, 2), "2025.2")));+ assert_eq!(product_dir("PyCharmCE2023.10"), Some(("PyCharmCE", (2023, 10), "2023.10")));+ assert_eq!(product_dir("AndroidStudio2024.3"), Some(("AndroidStudio", (2024, 3), "2024.3")));+ for name in+ ["Toolbox", "consentOptions", "IntelliJIdea2025", "Idea-2025.1", "2025.1", "Rider25.1", "Go Land2025.1"]+ {+ assert_eq!(product_dir(name), None, "{name}");+ }+ }++ #[test]+ fn locates_the_settings_and_plugins_of_each_os() {+ let tmp = tempfile::tempdir().unwrap();+ let home = tmp.path();+ let mk = |p: PathBuf| {+ std::fs::create_dir_all(&p).unwrap();+ p+ };+ let mac = mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.2"));+ mk(home.join("Library/Application Support/JetBrains/Toolbox"));+ let dirs = ide_dirs(Layout::Mac, home, |_| None);+ assert_eq!(dirs.len(), 1);+ assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.2");+ assert_eq!((dirs[0].config.clone(), dirs[0].plugins.clone()), (mac.clone(), mac.join("plugins")));++ let appdata = mk(home.join("Roaming"));+ let win = mk(appdata.join("JetBrains/PyCharm2024.3"));+ let studio = mk(appdata.join("Google/AndroidStudio2025.1"));+ let env = |k: &str| (k == "APPDATA").then(|| appdata.clone().into_os_string());+ let dirs = ide_dirs(Layout::Windows, home, env);+ assert_eq!(+ dirs.iter().map(|d| d.label.as_str()).collect::<Vec<_>>(),+ ["Android Studio 2025.1", "PyCharm 2024.3"]+ );+ assert_eq!(dirs[1].plugins, win.join("plugins"));+ assert_eq!(dirs[0].config, studio);++ let config = mk(home.join(".config/JetBrains/IdeaIC2024.1"));+ mk(home.join(".config/JetBrains/GoLand2025.2"));+ let dirs = ide_dirs(Layout::Xdg, home, |_| None);+ assert_eq!(dirs.iter().map(|d| d.product.as_str()).collect::<Vec<_>>(), ["GoLand", "IdeaIC"]);+ assert_eq!(dirs[1].label, "IntelliJ IDEA Community Edition 2024.1");+ assert_eq!(dirs[1].config, config);+ assert_eq!(dirs[1].plugins, home.join(".local/share/JetBrains/IdeaIC2024.1"));++ let xdg_data = home.join("data");+ let env = |k: &str| (k == "XDG_DATA_HOME").then(|| xdg_data.clone().into_os_string());+ assert_eq!(ide_dirs(Layout::Xdg, home, env)[1].plugins, xdg_data.join("JetBrains/IdeaIC2024.1"));+ }++ #[test]+ fn reads_the_selected_theme_from_laf_xml() {+ let tmp = tempfile::tempdir().unwrap();+ let laf = tmp.path().join("options/laf.xml");+ write(+ &laf,+ br#"<application>+ <component name="LafManager">+ <laf class-name="com.intellij.ide.ui.laf.UIThemeBasedLookAndFeelInfo" themeId="deep-sea-id" />+ <preferred-light-laf themeId="shallow-id" />+ </component>+</application>"#,+ );+ assert_eq!(active_theme_ids(tmp.path()), ["deep-sea-id"]);+ let synced = std::fs::read_to_string(&laf)+ .unwrap()+ .replace(r#"name="LafManager""#, r#"name="LafManager" autodetect="true""#);+ write(&laf, synced.as_bytes());+ assert_eq!(active_theme_ids(tmp.path()), ["deep-sea-id", "shallow-id"]);+ assert!(active_theme_ids(&tmp.path().join("missing")).is_empty());+ }++ #[test]+ fn lists_installed_theme_plugins_the_ides_current_first() {+ let tmp = tempfile::tempdir().unwrap();+ let config = tmp.path().join("IntelliJIdea2025.2");+ let plugins = config.join("plugins");+ write(&plugins.join("DeepSea/lib/deep-sea.jar"), &theme_jar());+ write(+ &plugins.join("Tools/lib/tools.jar"),+ &jar_bytes(&[(PLUGIN_XML, b"<idea-plugin><name>T</name></idea-plugin>")]),+ );+ write(&plugins.join("broken.jar"), b"not a jar");+ write(+ &config.join("options/laf.xml"),+ br#"<application><component name="LafManager"><laf themeId="shallow-id"/></component></application>"#,+ );+ let ide = IdeDir {+ label: "IntelliJ IDEA 2025.2".into(),+ product: "IntelliJIdea".into(),+ version: (2025, 2),+ config: config.clone(),+ plugins: plugins.clone(),+ };+ let found = find_installed(&[ide]);+ let theme = |id: &str, name: &str, dark: bool, active: bool| InstalledIntellijTheme {+ ide: "IntelliJ IDEA 2025.2".into(),+ plugin: "Deep Sea & Friends".into(),+ path: plugins.join("DeepSea").into(),+ theme_id: id.into(),+ theme_name: name.into(),+ dark,+ active,+ };+ assert_eq!(found, [theme("shallow-id", "Shallow", false, true), theme("deep-sea-id", "Deep Sea", true, false)]);+ assert!(find_installed(&[]).is_empty());+ }+}diff --git a/crates/ide-host/src/plugins/market.rs b/crates/ide-host/src/plugins/market.rsindex a9e045c14..4ab77fdb1 100644--- a/crates/ide-host/src/plugins/market.rs+++ b/crates/ide-host/src/plugins/market.rs@@ -4,10 +4,10 @@//! (`market-index.json`), checks signatures against it, and disables what it//! revokes — at start-up and on every refresh (the desktop refreshes daily).-use super::{PluginHost, PluginSource, PluginStatus};+use super::{PackageFile, PluginHost, PluginSource, PluginStatus};use ide_core::{IdeError, IdeResult};-use ide_extension::Manifest;use ide_extension::package::{self, Index, IndexEntry, PackageSignature, SIGNATURE_FILE};+use ide_extension::{MANIFEST_FILE, Manifest};use serde::{Deserialize, Serialize};use std::path::{Path, PathBuf};@@ -20,6 +20,8 @@ pub const INDEX_FILE: &str = "market-index.json";const DOWNLOADS: &str = ".downloads";const MAX_INDEX: usize = 16 << 20;const MAX_PACKAGE: usize = 256 << 20;+const MAX_STAGED_FILES: usize = 256;+const MAX_STAGED_BYTES: usize = 16 << 20;/// A marketplace entry with what is installed.#[derive(Clone, Debug, Serialize, Deserialize, specta::Type)]@@ -182,6 +184,45 @@ impl PluginHost {Ok(dir)}+ /// Writes a package the UI generated (an imported IntelliJ theme) into a+ /// folder next to the downloads, named after `name` (its plugin id); returns the folder.+ /// The install page validates it like any other package.+ pub fn stage_package(&self, name: &str, files: &[PackageFile]) -> IdeResult<PathBuf> {+ ide_extension::validate_item_id(name, "package name").map_err(IdeError::invalid)?;+ if !files.iter().any(|f| f.path == MANIFEST_FILE) {+ return Err(IdeError::invalid(format!("a package needs a {MANIFEST_FILE}")));+ }+ let total: usize = files.iter().map(|f| f.text.len()).sum();+ if files.len() > MAX_STAGED_FILES || total > MAX_STAGED_BYTES {+ return Err(IdeError::invalid("the package is too large"));+ }+ let mut seen = std::collections::HashSet::new();+ for f in files {+ let valid = !f.path.is_empty()+ && f.path.len() <= 255+ && f.path.split('/').all(|part| {+ !matches!(part, "" | "." | "..") && !part.contains(['\\', ':', '\0']) && !part.starts_with('.')+ });+ if !valid {+ return Err(IdeError::invalid(format!("invalid package path {:?}", f.path)));+ }+ if !seen.insert(f.path.to_ascii_lowercase()) {+ return Err(IdeError::invalid(format!("{} is in the package twice", f.path)));+ }+ }+ // One folder per package, replaced by the next import of it: they don't pile up.+ let dir = self.plugins_dir.join(DOWNLOADS).join(format!("{name}-generated"));+ let _ = std::fs::remove_dir_all(&dir);+ for f in files {+ let path = dir.join(&f.path);+ if let Some(parent) = path.parent() {+ std::fs::create_dir_all(parent)?;+ }+ std::fs::write(&path, &f.text)?;+ }+ Ok(dir)+ }+/// Files of the package in `dir` (what its declarations reference, and/// the component): what a package file holds besides the manifest.pub fn package_files_of(&self, dir: &Path) -> IdeResult<Vec<PathBuf>> {diff --git a/crates/ide-host/src/plugins/mod.rs b/crates/ide-host/src/plugins/mod.rsindex 631bec5ea..208da1385 100644--- a/crates/ide-host/src/plugins/mod.rs+++ b/crates/ide-host/src/plugins/mod.rs@@ -21,6 +21,7 @@ mod icon_patterns;mod icon_settings;mod icons;mod install;+pub mod intellij;mod market;mod points;mod providers;diff --git a/crates/ide-host/src/plugins/theme.rs b/crates/ide-host/src/plugins/theme.rsindex e4f38ff51..7b4fd88b7 100644--- a/crates/ide-host/src/plugins/theme.rs+++ b/crates/ide-host/src/plugins/theme.rs@@ -134,7 +134,7 @@ impl ExtensionPoint for ThemesPoint {/// Blanks out `//` and `/* */` comments outside strings, keeping newlines so/// parse errors still point at the right line.-fn strip_json_comments(src: &str) -> String {+pub(super) fn strip_json_comments(src: &str) -> String {let mut out = String::with_capacity(src.len());let mut chars = src.chars().peekable();let (mut in_str, mut escaped) = (false, false);diff --git a/crates/ide-host/src/plugins/types.rs b/crates/ide-host/src/plugins/types.rsindex c9cac4309..db3b18f9a 100644--- a/crates/ide-host/src/plugins/types.rs+++ b/crates/ide-host/src/plugins/types.rs@@ -212,6 +212,14 @@ impl PluginEditor {}}+/// A text file of a package the UI generated, at its `/`-separated path in the package.+#[derive(Clone, Debug, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct PackageFile {+ pub path: String,+ pub text: String,+}+/// A plugin's status bar item.#[derive(Clone, Debug, Serialize, Deserialize, Type)]#[serde(rename_all = "camelCase")]diff --git a/crates/ide-host/tests/plugins.rs b/crates/ide-host/tests/plugins.rsindex b052cd725..f4d361f9a 100644--- a/crates/ide-host/tests/plugins.rs+++ b/crates/ide-host/tests/plugins.rs@@ -2309,6 +2309,57 @@ fn a_zipped_plugin_folder_installs_like_the_folder() {assert!(err.contains("is not an OpenIDEA plugin"), "{err}");}+/// What the UI writes for an imported IntelliJ theme goes through the install page.+#[test]+fn a_generated_package_is_staged_for_the_install_page() {+ let f = fixture(Limits::default());+ let file = |path: &str, text: &str| PackageFile { path: path.into(), text: text.into() };+ let manifest = r#"id = "intellij.deep-sea"+name = "Deep Sea"+version = "2.3.0"+engines.openidea = "^1.0"++[[contributes.themes]]+path = "themes/deep-sea.theme.json"+editor-scheme = "themes/deep-sea.scheme.json"+"#;+ let files = [+ file("plugin.toml", manifest),+ file(+ "themes/deep-sea.theme.json",+ r##"{"id":"deep-sea","name":"Deep Sea","kind":"dark","tokens":{"--bg-app":"#101820"}}"##,+ ),+ file("themes/deep-sea.scheme.json", r##"{"name":"Deep Sea","tokens":{"--syn-keyword":"#cc7832"}}"##),+ ];+ let dir = f.host.stage_package("intellij.deep-sea", &files).unwrap();+ let preview = f.host.preview_install(&dir).unwrap();+ assert_eq!((preview.id.as_str(), preview.has_code, preview.unsigned), ("intellij.deep-sea", false, true));+ assert!(preview.capabilities.is_empty());+ f.install(&dir);+ let active = f.host.set_theme(Some(("intellij.deep-sea", "deep-sea"))).unwrap().unwrap();+ assert_eq!(active.theme.tokens["--bg-app"], "#101820");+ assert_eq!(active.theme.tokens["--syn-keyword"], "#cc7832");++ // Staging the same package again starts from an empty folder; importing it again replaces it.+ assert_eq!(f.host.stage_package("intellij.deep-sea", &files[..1]).unwrap(), dir);+ assert!(!dir.join("themes").exists());+ let mut changed = files.clone();+ changed[2] = file("themes/deep-sea.scheme.json", r##"{"tokens":{"--syn-keyword":"#ff8800"}}"##);+ f.install(&f.host.stage_package("intellij.deep-sea", &changed).unwrap());+ let active = f.host.set_theme(Some(("intellij.deep-sea", "deep-sea"))).unwrap().unwrap();+ assert_eq!(active.theme.tokens["--syn-keyword"], "#ff8800");++ for bad in ["../x", "/abs", "a//b", r"a\b", "C:x", ".hidden", "a/./b", ""] {+ let err = f.host.stage_package("p", &[file("plugin.toml", manifest), file(bad, "x")]).unwrap_err().message;+ assert!(err.contains("invalid package path"), "{bad:?}: {err}");+ }+ let err = f.host.stage_package("p", &[file("x.json", "{}")]).unwrap_err().message;+ assert!(err.contains("needs a plugin.toml"), "{err}");+ let err = f.host.stage_package("p", &[file("plugin.toml", ""), file("PLUGIN.toml", "")]).unwrap_err().message;+ assert!(err.contains("twice"), "{err}");+ assert!(f.host.stage_package("../p", &files).is_err());+}+/// Secrets live outside the plugin's directory (the OS keychain on the/// desktop): uninstalling the plugin deletes the ones it declares.#[test]diff --git a/docs/plugins/themes.md b/docs/plugins/themes.mdindex b11082a35..7f13e1ef4 100644--- a/docs/plugins/themes.md+++ b/docs/plugins/themes.md@@ -132,9 +132,29 @@ and credit the original authors in `authors` and `description`.### From IntelliJ IDEA (automatic)+To use a theme you already have in IntelliJ, open **Settings › Plugins**, gear+menu:++- **Import Theme from IntelliJ IDE…** lists the theme plugins installed in the+ JetBrains IDEs (and Android Studio) on this computer, the theme each IDE uses+ first. It reads their settings folders: `~/Library/Application Support/JetBrains`+ (macOS), `%APPDATA%\JetBrains` (Windows), `~/.config/JetBrains` and+ `~/.local/share/JetBrains` (Linux).+- **Import IntelliJ Theme from File…** takes a theme plugin downloaded from the+ JetBrains Marketplace (`.jar`, or a `.zip` with the plugin's `lib/*.jar`) or a+ `.theme.json` (its `editorScheme` file is read from the same folder).++The whole plugin becomes one OpenIDEA theme plugin, `intellij.<plugin id>`, with+each of its themes and their editor schemes; it is installed through the usual+install page and the chosen theme (otherwise the first) is applied. Importing+the plugin again replaces it. Both are actions too (`plugins.importIntellijTheme`,+`plugins.importInstalledIntellijTheme`). The conversion is the one described+below.+`scripts/theme/import-intellij-theme.ts` converts an IntelliJ `.theme.json`,-and optionally its `.icls` editor scheme, into a ready-to-install plugin. It-has no dependencies beyond Node 22.+and optionally its `.icls` editor scheme, into a plugin folder you can edit+before installing it — the way to port a theme for publishing. It has no+dependencies beyond Node 22.```shpnpm theme:import-intellij path/to/MyTheme.theme.json path/to/MyTheme.icls --out ~/my-theme --author "Original Author"@@ -179,7 +199,7 @@ ship no `.icls` at all keep the built-in syntax colours.| `--bg-toggle-*` | `ToggleButton.onBackground`, `.offBackground`, `.buttonColor` || `--bg-feedback-*`, `--border-feedback-*` | `Banner.infoBackground`, `Banner.errorBorderColor`, … |-The full table is `UI_KEYS` in [`scripts/theme/intellij.ts`](../../scripts/theme/intellij.ts).+The full table is `UI_KEYS` in [`src/features/plugins/intellijTheme.ts`](../../src/features/plugins/intellijTheme.ts).#### `.icls` → editor schemediff --git a/plugins/README.md b/plugins/README.mdindex 5bc1d385e..d90839c11 100644--- a/plugins/README.md+++ b/plugins/README.md@@ -728,7 +728,9 @@ granted, and starts the approved program.- **Install:** Settings › Plugins › _Install Plugin from Disk…_ (a packagefolder) or _Install Plugin from Package File…_ (a `.oiplugin`, a `.zip` withthe package at its root or in its only folder, or a folder's `plugin.toml`;- a zip without a `plugin.toml` there, such as an IntelliJ plugin, is refused). The install+ a zip without a `plugin.toml` there, such as an IntelliJ plugin, is refused; IntelliJ+ theme plugins are imported instead: _Import IntelliJ Theme from File…_ and _Import Theme+ from IntelliJ IDE…_, see [`docs/plugins/themes.md`](../docs/plugins/themes.md)). The installpage lists every capability and whether the package is signed by a publisherthe marketplace trusts; nothing is copied until you accept.- **Versions:** installed plugins live in `<app-data>/plugins/<id>/<version>/`diff --git a/scripts/theme/import-intellij-theme.ts b/scripts/theme/import-intellij-theme.tsindex 4fdd0cf18..d294c1ce5 100644--- a/scripts/theme/import-intellij-theme.ts+++ b/scripts/theme/import-intellij-theme.ts@@ -10,7 +10,8 @@import { mkdirSync, readFileSync, writeFileSync } from "node:fs";import { basename, join } from "node:path";import { parseArgs } from "node:util";-import { convertIntellijTheme, pluginManifest } from "./intellij.ts";+import { convertIntellijTheme, pluginManifest } from "../../src/features/plugins/intellijTheme.ts";+import { stripJsonComments } from "./tokens.ts";const { values, positionals } = parseArgs({allowPositionals: true,@@ -25,7 +26,7 @@ if (!themePath || !values.out) {}const converted = convertIntellijTheme(- readFileSync(themePath, "utf8"),+ stripJsonComments(readFileSync(themePath, "utf8")),iclsPath ? readFileSync(iclsPath, "utf8") : undefined,values.id,);@@ -34,7 +35,17 @@ const source = [basename(themePath), iclsPath && basename(iclsPath)].filter(Boolconst header = (what: string) => `// ${theme.name}: ${what}, converted from ${source}.\n`;mkdirSync(join(values.out, "themes"), { recursive: true });-writeFileSync(join(values.out, "plugin.toml"), pluginManifest(converted, values.author ?? "Unknown", source));+const info = {+ id: `theme-${theme.id}`,+ name: `${theme.name} Theme`,+ version: "1.0.0",+ description: `${theme.name}, converted from an IntelliJ theme.`,+ authors: [values.author ?? "Unknown"],+};+writeFileSync(+ join(values.out, "plugin.toml"),+ pluginManifest(info, [converted], `Converted from ${source} by scripts/theme/import-intellij-theme.ts.`),+);writeFileSync(join(values.out, "themes", `${theme.id}.theme.json`),header("UI theme") + JSON.stringify(theme, null, 2) + "\n",diff --git a/scripts/theme/theme.test.ts b/scripts/theme/theme.test.tsindex bf5333296..4e340c609 100644--- a/scripts/theme/theme.test.ts+++ b/scripts/theme/theme.test.ts@@ -5,9 +5,10 @@ import {convertIntellijTheme,ICLS_ATTRIBUTES,ICLS_COLORS,+ intellijThemePackage,pluginManifest,UI_KEYS,-} from "./intellij.ts";+} from "../../src/features/plugins/intellijTheme.ts";import { referenceMarkdown, stripJsonComments, themeTokenGroups, tokenSets, withReference } from "./tokens.ts";const read = (p: string) => readFileSync(p, "utf8");@@ -129,7 +130,7 @@ describe("IntelliJ theme import", () => {</scheme>`;it("maps ui keys, named colours and wildcards", () => {- const { theme: t, scheme: s } = convertIntellijTheme(themeJson);+ const { theme: t, scheme: s } = convertIntellijTheme(stripJsonComments(themeJson));expect(t).toMatchObject({ id: "deep-sea", name: "Deep Sea", kind: "dark" });expect(t.tokens["--bg-app"]).toBe("#101820"); // *.background → named colourexpect(t.tokens["--accent"]).toBe("#33aaff");@@ -172,12 +173,71 @@ describe("IntelliJ theme import", () => {});it("produces an installable package", () => {- const c = convertIntellijTheme(themeJson.replace('"dark": true,', ""), icls.replace("Darcula", "Default"), "sea");+ const light = stripJsonComments(themeJson.replace('"dark": true,', ""));+ const c = convertIntellijTheme(light, icls.replace("Darcula", "Default"), "sea");expect(c.theme.kind).toBe("light");expect(c.theme.id).toBe("sea");expect(c.theme.tokens["--bg-island"]).toBe("#101820"); // ToolWindow ← *.background wins over the editor- const toml = pluginManifest(c, "Someone", "DeepSea.theme.json");+ const info = {+ id: "theme-sea",+ name: 'Sea "Deep"',+ version: "1.0.0",+ description: "a\\b\nc",+ authors: ["Someone"],+ };+ const toml = pluginManifest(info, [c], "Converted from\nDeepSea.theme.json");+ expect(toml).toContain("# Converted from DeepSea.theme.json\n");expect(toml).toContain('id = "theme-sea"');+ expect(toml).toContain('name = "Sea \\"Deep\\""');+ expect(toml).toContain('description = "a\\\\b\\u000ac"');+ expect(toml).toContain('engines.openidea = "^1.0"');expect(toml).toContain('editor-scheme = "themes/sea.scheme.json"');});++ it("turns a theme plugin into one package with all its themes", () => {+ const deep = stripJsonComments(themeJson);+ const pkg = intellijThemePackage({+ name: "Deep Sea Themes",+ pluginId: "com.example.DeepSea",+ version: "2.3",+ vendor: "Someone",+ themes: [+ { id: "deep-sea-id", theme: deep, editorScheme: icls },+ { id: "copy-id", theme: deep, editorScheme: null },+ { id: "light-id", theme: '{"name":"Shallow","dark":false}', editorScheme: null },+ ],+ });+ expect(pkg.id).toBe("intellij.com-example-deepsea");+ expect(pkg.themes).toEqual([+ { id: "deep-sea", sourceId: "deep-sea-id", name: "Deep Sea" },+ { id: "deep-sea-2", sourceId: "copy-id", name: "Deep Sea" },+ { id: "shallow", sourceId: "light-id", name: "Shallow" },+ ]);+ expect(pkg.files.map((f) => f.path)).toEqual([+ "plugin.toml",+ "themes/deep-sea.theme.json",+ "themes/deep-sea.scheme.json",+ "themes/deep-sea-2.theme.json",+ "themes/shallow.theme.json",+ ]);+ const manifest = pkg.files[0]!.text;+ expect(manifest).toContain('version = "2.3.0"');+ expect(manifest).toContain('authors = ["Someone"]');+ expect(manifest.match(/\[\[contributes\.themes\]\]/g)).toHaveLength(3);+ const shallow = JSON.parse(pkg.files[4]!.text) as { id: string; kind: string };+ expect(shallow).toMatchObject({ id: "shallow", kind: "light" });+ expect(+ intellijThemePackage({+ name: "X",+ pluginId: null,+ version: "SNAPSHOT",+ vendor: null,+ themes: [{ id: "x", theme: "{}", editorScheme: null }],+ }).files[0]!.text,+ ).toContain('version = "1.0.0"');+ expect(() =>+ intellijThemePackage({ name: "Empty", pluginId: null, version: null, vendor: null, themes: [] }),+ ).toThrow();+ expect(() => convertIntellijTheme("[1]")).toThrow("Not an IntelliJ theme");+ });});diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex 20884ff9e..ffae151c9 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -457,6 +457,9 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {plugin::plugin_set_market_url,plugin::plugin_market_download,plugin::plugin_unpack_package,+ plugin::plugin_read_intellij_theme,+ plugin::plugin_installed_intellij_themes,+ plugin::plugin_stage_package,plugin::plugin_roll_back,plugin::plugin_secrets,plugin::plugin_set_secret,diff --git a/src-tauri/src/commands/plugin.rs b/src-tauri/src/commands/plugin.rsindex 3698057b0..998c591ad 100644--- a/src-tauri/src/commands/plugin.rs+++ b/src-tauri/src/commands/plugin.rs@@ -6,9 +6,10 @@use crate::state::AppState;use ide_core::{IdeError, IdeResult};use ide_extension::ActivationEvent;+use ide_host::plugins::intellij::{self, InstalledIntellijTheme, IntellijThemeSource};use ide_host::plugins::{- ActiveTheme, CatalogPlugin, Consent, EventKind, HostWorkspace, InstallPreview, PluginEditor, PluginEvent,- PluginHost, PluginInfo, PluginStatusItem, PluginsSnapshot, WorkbenchEvent,+ ActiveTheme, CatalogPlugin, Consent, EventKind, HostWorkspace, InstallPreview, PackageFile, PluginEditor,+ PluginEvent, PluginHost, PluginInfo, PluginStatusItem, PluginsSnapshot, WorkbenchEvent,};use ide_plugin::{Invocation, Limits};use parking_lot::Mutex;@@ -512,6 +513,32 @@ pub async fn plugin_unpack_package(state: State<'_, AppState>, path: PathBuf) ->blocking(move || host.unpack_package(&path)).await}+/// Reads an IntelliJ theme plugin (`.jar`, Marketplace `.zip`, plugin folder) or `.theme.json` to import.+#[tauri::command]+#[specta::specta]+pub async fn plugin_read_intellij_theme(path: PathBuf) -> IdeResult<IntellijThemeSource> {+ blocking(move || intellij::read_source(&path)).await+}++/// Theme plugins installed in the JetBrains IDEs of this user, the ones in use first.+#[tauri::command]+#[specta::specta]+pub async fn plugin_installed_intellij_themes() -> IdeResult<Vec<InstalledIntellijTheme>> {+ blocking(|| Ok(intellij::installed_themes())).await+}++/// Writes a package the UI generated (an imported theme); returns the folder for the install page.+#[tauri::command]+#[specta::specta]+pub async fn plugin_stage_package(+ state: State<'_, AppState>,+ name: String,+ files: Vec<PackageFile>,+) -> IdeResult<PathBuf> {+ let host = state.plugins.clone();+ blocking(move || host.stage_package(&name, &files)).await+}+/// Goes back to the version the last update of `id` replaced.#[tauri::command]#[specta::specta]diff --git a/src/bindings.ts b/src/bindings.tsindex 5d09fc499..c78b7e459 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -987,6 +987,12 @@ export const commands = {pluginMarketDownload: (id: string) => typedError<string, IdeError>(__TAURI_INVOKE("plugin_market_download", { id })),/** Unpacks a package file (`.oiplugin` or `.zip`); returns the folder for the install page. */pluginUnpackPackage: (path: string) => typedError<string, IdeError>(__TAURI_INVOKE("plugin_unpack_package", { path })),+ /** Reads an IntelliJ theme plugin (`.jar`, Marketplace `.zip`, plugin folder) or `.theme.json` to import. */+ pluginReadIntellijTheme: (path: string) => typedError<IntellijThemeSource, IdeError>(__TAURI_INVOKE("plugin_read_intellij_theme", { path })),+ /** Theme plugins installed in the JetBrains IDEs of this user, the ones in use first. */+ pluginInstalledIntellijThemes: () => typedError<InstalledIntellijTheme[], IdeError>(__TAURI_INVOKE("plugin_installed_intellij_themes")),+ /** Writes a package the UI generated (an imported theme); returns the folder for the install page. */+ pluginStagePackage: (name: string, files: PackageFile[]) => typedError<string, IdeError>(__TAURI_INVOKE("plugin_stage_package", { name, files })),/** Goes back to the version the last update of `id` replaced. */pluginRollBack: (id: string) => typedError<PluginInfo, IdeError>(__TAURI_INVOKE("plugin_roll_back", { id })),pluginSecrets: (pluginId: string) => typedError<PluginSecretState[], IdeError>(__TAURI_INVOKE("plugin_secrets", { pluginId })),@@ -4292,6 +4298,40 @@ export type InstallPreview = {publisher: string | null,};+/** A theme of a plugin installed in a JetBrains IDE. */+export type InstalledIntellijTheme = {+ /** The IDE and its version: `IntelliJ IDEA 2025.2`. */+ ide: string,+ /** The plugin's name. */+ plugin: string,+ /** What to import: the plugin's folder or jar. */+ path: IpcPath,+ themeId: string,+ themeName: string,+ dark: boolean,+ /** The IDE is set to this theme. */+ active: boolean,+};++export type IntellijThemeFile = {+ /** The `themeProvider` id (what `laf.xml` names), or the file name without `.theme.json`. */+ id: string,+ /** The `.theme.json`, comments removed. */+ theme: string,+ /** The editor scheme (`.icls` XML) its `editorScheme` names, when the plugin has it. */+ editorScheme: string | null,+};++/** A theme plugin's themes, as read from its files. */+export type IntellijThemeSource = {+ /** The plugin's `<name>`, or the theme's for a loose file. */+ name: string,+ pluginId: string | null,+ version: string | null,+ vendor: string | null,+ themes: IntellijThemeFile[],+};+/** Optional parts of the invalidation; the symbol index is always rebuilt. */export type InvalidateCachesOptions = {/** Local History of every project. */@@ -5151,6 +5191,12 @@ export type OutputChunk = { kind: "stdout"; text: string } | { kind: "stderr"; t/** System message from the IDE (command line echo, exit code). */{ kind: "system"; text: string };+/** A text file of a package the UI generated, at its `/`-separated path in the package. */+export type PackageFile = {+ path: string,+ text: string,+};+/** A file of a partial commit: which of its changes against HEAD to commit. */export type PartialCommitFile = {path: IpcPath,diff --git a/src/features/plugins/IntellijThemesDialog.tsx b/src/features/plugins/IntellijThemesDialog.tsxnew file mode 100644index 000000000..7924b6396--- /dev/null+++ b/src/features/plugins/IntellijThemesDialog.tsx@@ -0,0 +1,140 @@+/**+ * Import Theme from IntelliJ IDE: the theme plugins installed in the JetBrains+ * IDEs on this machine, each under its plugin's heading, the plugin of the+ * theme in use first. Importing a theme brings every theme of its plugin, as+ * installing the plugin in IntelliJ does, and applies the chosen one+ * (`importIntellijTheme`). A file can be chosen instead.+ */+import { useEffect, useState } from "react";+import clsx from "clsx";+import type { InstalledIntellijTheme } from "@/bindings";+import { tx } from "@/platform/i18n";+import { Badge, Dialog, List, Spinner, T } from "@/ui";+import { pluginsBackend } from "./backend";+import { closeInstalledIntellijThemes, importIntellijTheme, useIntellijThemesDialog } from "./intellijImport";+import { errorText } from "./store";+import styles from "./PluginsPage.module.css";++type Row =+ | { kind: "plugin"; key: string; plugin: string; ide: string; count: number; first: boolean }+ | { kind: "theme"; key: string; theme: InstalledIntellijTheme };++/** A heading per plugin (of an IDE) with its themes under it, in the order found (the one in use first). */+function themeRows(themes: readonly InstalledIntellijTheme[]): Row[] {+ const plugins = new Map<string, InstalledIntellijTheme[]>();+ for (const t of themes) {+ const key = `${t.ide}\n${t.path}`;+ plugins.set(key, [...(plugins.get(key) ?? []), t]);+ }+ return [...plugins].flatMap(([key, list], i): Row[] => [+ { kind: "plugin", key, plugin: list[0]!.plugin, ide: list[0]!.ide, count: list.length, first: i === 0 },+ ...list.map((theme): Row => ({ kind: "theme", key: `${key}\n${theme.themeId}`, theme })),+ ]);+}++function IntellijThemesDialog() {+ const [themes, setThemes] = useState<InstalledIntellijTheme[] | null>(null);+ const [error, setError] = useState<string | null>(null);+ // The first theme, under the first heading.+ const [active, setActive] = useState(1);+ useEffect(() => {+ let live = true;+ pluginsBackend()+ .installedIntellijThemes()+ .then(+ (found) => live && setThemes(found),+ (e: unknown) => {+ if (!live) return;+ setError(errorText(e));+ setThemes([]);+ },+ );+ return () => {+ live = false;+ };+ }, []);++ const run = (theme?: InstalledIntellijTheme) => {+ const { onImported } = useIntellijThemesDialog.getState();+ closeInstalledIntellijThemes();+ void importIntellijTheme(theme?.path, theme?.themeId).then((id) => id && onImported?.(id));+ };+ const rows = themeRows(themes ?? []);+ const row = rows[active];+ const chosen = row?.kind === "theme" ? row.theme : undefined;++ return (+ <Dialog+ open+ title="Import Theme from IntelliJ IDE"+ width={640}+ onClose={closeInstalledIntellijThemes}+ buttons={[+ { label: "Choose File…", role: "extra", onClick: () => run() },+ { label: "Cancel", role: "cancel" },+ { label: "Import", role: "default", disabled: !chosen, onClick: () => chosen && run(chosen) },+ ]}+ >+ <div className={styles.intellijThemes}>+ <p className={styles.muted}>+ <T>+ Theme plugins installed in the JetBrains IDEs on this computer. Importing a theme brings every theme of its+ plugin and applies the chosen one. Colours without an OpenIDEA counterpart keep the default theme colours.+ </T>+ </p>+ {themes === null ? (+ <div className={styles.intellijThemesStatus}>+ <Spinner size={14} label="Looking for IntelliJ themes" />+ <T>Looking for IntelliJ themes…</T>+ </div>+ ) : (+ <List+ items={rows}+ getKey={(r) => r.key}+ isSection={(r) => r.kind === "plugin"}+ activeIndex={chosen ? active : -1}+ onActiveChange={setActive}+ rowHeight={28}+ sectionHeight={30}+ className={styles.intellijThemesList}+ aria-label={tx("IntelliJ themes")}+ empty={+ <div className={styles.intellijThemesStatus} role="note">+ {error ?? (+ <T>+ No theme plugins found in JetBrains IDEs on this computer. Choose a theme plugin downloaded from the+ JetBrains Marketplace (.jar or .zip) or a .theme.json file instead.+ </T>+ )}+ </div>+ }+ renderSection={(r) =>+ r.kind === "plugin" && (+ <div className={clsx(styles.intellijPlugin, !r.first && styles.intellijPluginNext)}>+ <span className={styles.intellijPluginName}>{r.plugin}</span>+ <span>{r.count === 1 ? tx("1 theme") : tx`${r.count} themes`}</span>+ <span className={styles.intellijPluginIde}>{r.ide}</span>+ </div>+ )+ }+ renderItem={(r) =>+ r.kind === "theme" && (+ <div className={styles.intellijTheme}>+ <span className={styles.itemMain}>{r.theme.themeName}</span>+ {r.theme.active && <Badge tone="accent">{tx("In use")}</Badge>}+ <span className={styles.muted}>{r.theme.dark ? tx("Dark") : tx("Light")}</span>+ </div>+ )+ }+ />+ )}+ </div>+ </Dialog>+ );+}++/** Overlay of the dialog while `showInstalledIntellijThemes` has it open. */+export function IntellijThemesDialogHost() {+ const open = useIntellijThemesDialog((s) => s.open);+ return open ? <IntellijThemesDialog /> : null;+}diff --git a/src/features/plugins/PluginsPage.module.css b/src/features/plugins/PluginsPage.module.cssindex f54100aa9..1f4b0e8de 100644--- a/src/features/plugins/PluginsPage.module.css+++ b/src/features/plugins/PluginsPage.module.css@@ -384,3 +384,63 @@padding: 12px 16px;overflow: auto;}++/* Import Theme from IntelliJ IDE */+.intellijThemes {+ display: flex;+ flex-direction: column;+ gap: 10px;+ min-width: 0;+ padding: 14px;+}+.intellijThemes > p {+ margin: 0;+}+/* As tall as its rows (the list sizes them), scrolling past seven. */+.intellijThemesList {+ max-height: 316px;+ padding: 4px 0;+ border: 1px solid var(--border);+ border-radius: var(--radius-control);+}+.intellijThemesStatus {+ display: flex;+ align-items: center;+ gap: 8px;+ padding: 8px 10px;+ color: var(--fg-muted);+}+.intellijTheme {+ display: flex;+ flex: 1;+ align-items: center;+ gap: 8px;+ min-width: 0;+}+.intellijTheme > .muted {+ flex-shrink: 0;+ font-size: var(--fs-small);+}+.intellijPlugin {+ display: flex;+ flex: 1;+ align-items: center;+ gap: 8px;+ align-self: stretch;+ min-width: 0;+}+/* A line above each plugin but the first, as in IDEA's Theme list. */+.intellijPluginNext {+ border-top: 1px solid var(--border);+}+.intellijPluginName {+ overflow: hidden;+ color: var(--fg-secondary);+ font-weight: 600;+ text-overflow: ellipsis;+ white-space: nowrap;+}+.intellijPluginIde {+ flex-shrink: 0;+ margin-left: auto;+}diff --git a/src/features/plugins/PluginsPage.tsx b/src/features/plugins/PluginsPage.tsxindex 662e7dc0c..33a2065a9 100644--- a/src/features/plugins/PluginsPage.tsx+++ b/src/features/plugins/PluginsPage.tsx@@ -43,6 +43,8 @@ import {uninstallPlugin,usePlugins,} from "./store";+import { useProject } from "@/platform/project";+import { importIntellijTheme, showInstalledIntellijThemes } from "./intellijImport";import styles from "./PluginsPage.module.css";import { tx } from "@/platform/i18n";@@ -526,11 +528,26 @@ function CatalogDetails({ entry }: { entry: CatalogPlugin }) {);}-function gearMenu(plugins: readonly PluginInfo[], install: (packageFile: boolean) => void): MenuItem[] {+interface GearActions {+ /** Installing needs a trusted project's window (the host refuses it elsewhere). */+ canImport: boolean;+ install: (packageFile: boolean) => void;+ importIntellijFile: () => void;+ importInstalledIntellij: () => void;+}++function gearMenu(plugins: readonly PluginInfo[], actions: GearActions): MenuItem[] {const installed = plugins.filter((p) => p.source === "installed");return [- { label: "Install Plugin from Disk…", icon: "package", run: () => install(false) },- { label: "Install Plugin from Package File…", run: () => install(true) },+ { label: "Install Plugin from Disk…", icon: "package", run: () => actions.install(false) },+ { label: "Install Plugin from Package File…", run: () => actions.install(true) },+ ...(actions.canImport+ ? [+ { kind: "separator" as const },+ { label: "Import Theme from IntelliJ IDE…", run: actions.importInstalledIntellij },+ { label: "Import IntelliJ Theme from File…", run: actions.importIntellijFile },+ ]+ : []),{ kind: "separator" },{label: "Disable All Downloaded Plugins",@@ -700,19 +717,22 @@ export function PluginsPage() {const catalogShown = useMemo(() => filterCatalog(catalog ?? [], query), [catalog, query]);const selectedEntry = catalogShown.find((c) => c.id === selectedCatalogId) ?? catalogShown[0] ?? null;- const install = async (packageFile = false) => {- const id = await installFromDisk(undefined, packageFile);- if (id) {- setTab("installed");- setSelectedId(id);- }+ const showInstalled = (id: string | null) => {+ if (!id) return;+ setTab("installed");+ setSelectedId(id);};const openGear = (e: MouseEvent<HTMLButtonElement>) => {const r = e.currentTarget.getBoundingClientRect();showContextMenu({ x: r.left, y: r.bottom + 2 },- gearMenu(plugins, (packageFile) => void install(packageFile)),+ gearMenu(plugins, {+ canImport: useProject.getState().project?.trusted === true,+ install: (packageFile) => void installFromDisk(undefined, packageFile).then(showInstalled),+ importIntellijFile: () => void importIntellijTheme().then(showInstalled),+ importInstalledIntellij: () => showInstalledIntellijThemes(showInstalled),+ }),);};diff --git a/src/features/plugins/__tests__/intellijImport.test.tsx b/src/features/plugins/__tests__/intellijImport.test.tsxnew file mode 100644index 000000000..611f4e88d--- /dev/null+++ b/src/features/plugins/__tests__/intellijImport.test.tsx@@ -0,0 +1,194 @@+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from "vitest";+import { act, render, screen, waitFor, within } from "@testing-library/react";+import userEvent from "@testing-library/user-event";+import type { InstalledIntellijTheme, InstallPreview, IntellijThemeSource } from "@/bindings";+import { IpcError } from "@/platform/ipc";+import { provideNotificationService, type NotificationService } from "@/workbench/contributions";+import { useThemeOverride } from "@/workbench/theme";+import { createMemoryPluginsBackend, setPluginsBackend, type PluginsBackend } from "../backend";+import { closeInstalledIntellijThemes, importIntellijTheme, showInstalledIntellijThemes } from "../intellijImport";+import { IntellijThemesDialogHost } from "../IntellijThemesDialog";+import { setConsentPrompt } from "../store";++type Note = Parameters<NotificationService["notify"]>[0];+const ID = "intellij.com-example-deepsea";+const SOURCE: IntellijThemeSource = {+ name: "Deep Sea Themes",+ pluginId: "com.example.deepsea",+ version: "2.3",+ vendor: "Someone",+ themes: [+ { id: "deep-id", theme: '{"name":"Deep Sea","dark":true,"ui":{"*":{"background":"#101820"}}}', editorScheme: null },+ { id: "shallow-id", theme: '{"name":"Shallow","dark":false}', editorScheme: null },+ ],+};+const INSTALLED: InstalledIntellijTheme[] = [+ {+ ide: "IntelliJ IDEA 2025.2",+ plugin: "Deep Sea Themes",+ path: "/ij/plugins/DeepSea",+ themeId: "shallow-id",+ themeName: "Shallow",+ dark: false,+ active: true,+ },+ {+ ide: "IntelliJ IDEA 2025.2",+ plugin: "Deep Sea Themes",+ path: "/ij/plugins/DeepSea",+ themeId: "deep-id",+ themeName: "Deep Sea",+ dark: true,+ active: false,+ },+];++let notes: Note[];+let read: Mock<PluginsBackend["readIntellijTheme"]>;+let stage: Mock<PluginsBackend["stagePackage"]>;+let installed: string[];++function backend(overrides: Partial<PluginsBackend> = {}): PluginsBackend {+ const base = createMemoryPluginsBackend();+ const preview: InstallPreview = {+ id: ID,+ name: SOURCE.name,+ version: "2.3.0",+ description: "",+ authors: ["Someone"],+ hasCode: false,+ capabilities: [],+ contributions: [{ point: "themes", count: 2 }],+ warnings: [],+ replaces: null,+ unsigned: true,+ publisher: null,+ };+ return {+ ...base,+ readIntellijTheme: read,+ stagePackage: stage,+ installedIntellijThemes: async () => INSTALLED,+ previewInstall: async () => preview,+ installDir: async (path) => {+ installed.push(path);+ const [template] = (await base.list()).plugins;+ return { ...template!, id: ID, name: SOURCE.name, hasCode: false, status: "static" };+ },+ ...overrides,+ };+}++beforeEach(() => {+ notes = [];+ installed = [];+ provideNotificationService({ notify: (n) => void notes.push(n) });+ read = vi.fn<PluginsBackend["readIntellijTheme"]>(async () => SOURCE);+ stage = vi.fn<PluginsBackend["stagePackage"]>(async () => "/app/plugins/.downloads/generated");+ setPluginsBackend(backend());+ setConsentPrompt(async () => ({ optional: [] }));+ useThemeOverride.setState({ theme: null });+});++afterEach(() => {+ closeInstalledIntellijThemes();+ setConsentPrompt(null);+ setPluginsBackend(null);+ useThemeOverride.setState({ theme: null });+});++describe("IntelliJ theme import", () => {+ it("installs the converted plugin through the install page and applies the chosen theme", async () => {+ expect(await importIntellijTheme("/downloads/DeepSea.zip", "shallow-id")).toBe(ID);+ expect(read).toHaveBeenCalledWith("/downloads/DeepSea.zip");+ const [name, files] = stage.mock.calls[0]!;+ expect(name).toBe(ID);+ expect(files.map((f) => f.path)).toEqual([+ "plugin.toml",+ "themes/deep-sea.theme.json",+ "themes/shallow.theme.json",+ ]);+ expect(installed).toEqual(["/app/plugins/.downloads/generated"]);+ expect(useThemeOverride.getState().theme).toBe(`plugin:${ID}/shallow`);+ });++ it("applies the first theme without a choice, and nothing when the install is declined", async () => {+ expect(await importIntellijTheme("/downloads/DeepSea.jar")).toBe(ID);+ expect(useThemeOverride.getState().theme).toBe(`plugin:${ID}/deep-sea`);++ useThemeOverride.setState({ theme: null });+ setConsentPrompt(async () => null);+ expect(await importIntellijTheme("/downloads/DeepSea.jar")).toBeNull();+ expect(useThemeOverride.getState().theme).toBeNull();+ });++ it("asks for a file without a path, and does nothing when the picker is cancelled", async () => {+ const pick = vi.fn(async () => null);+ setPluginsBackend(backend({ pickIntellijTheme: pick }));+ expect(await importIntellijTheme()).toBeNull();+ expect(pick).toHaveBeenCalledOnce();+ expect(read).not.toHaveBeenCalled();+ expect(notes).toEqual([]);+ });++ it("reports a file that is not a theme plugin", async () => {+ read.mockRejectedValueOnce(+ new IpcError({+ kind: "invalidInput",+ message: "tools.jar is not a theme plugin: its plugin.xml declares no themeProvider",+ }),+ );+ expect(await importIntellijTheme("/downloads/tools.jar")).toBeNull();+ expect(stage).not.toHaveBeenCalled();+ expect(notes).toEqual([+ expect.objectContaining({+ level: "error",+ title: "Could not import the IntelliJ theme",+ body: expect.stringContaining("not a theme plugin"),+ }),+ ]);+ });+});++describe("Import Theme from IntelliJ IDE", () => {+ it("lists the installed themes by plugin, the one in use first, and imports the chosen one", async () => {+ const user = userEvent.setup();+ const onImported = vi.fn();+ render(<IntellijThemesDialogHost />);+ act(() => showInstalledIntellijThemes(onImported));+ const list = await screen.findByRole("listbox", { name: "IntelliJ themes" });+ const options = await waitFor(() => {+ const found = Array.from(list.querySelectorAll('[role="option"]'));+ expect(found).toHaveLength(2);+ return found;+ });+ // Both under their plugin's heading: importing one brings the plugin's every theme.+ expect(within(list).getByText("Deep Sea Themes")).toBeInTheDocument();+ expect(within(list).getByText("2 themes")).toBeInTheDocument();+ expect(within(list).getByText("IntelliJ IDEA 2025.2")).toBeInTheDocument();+ expect(options[0]).toHaveTextContent("Shallow");+ expect(options[0]).toHaveTextContent("In use");+ expect(options[1]).toHaveTextContent("Deep Sea");+ expect(options[1]).not.toHaveTextContent("In use");++ await user.click(screen.getByText("Deep Sea"));+ await user.click(screen.getByRole("button", { name: "Import" }));+ await waitFor(() => expect(onImported).toHaveBeenCalledWith(ID));+ expect(read).toHaveBeenCalledWith("/ij/plugins/DeepSea");+ expect(useThemeOverride.getState().theme).toBe(`plugin:${ID}/deep-sea`);+ expect(screen.queryByRole("listbox", { name: "IntelliJ themes" })).toBeNull();+ });++ it("offers a file when no IDE has theme plugins", async () => {+ const user = userEvent.setup();+ const pick = vi.fn(async () => "/downloads/DeepSea.jar");+ setPluginsBackend(backend({ installedIntellijThemes: async () => [], pickIntellijTheme: pick }));+ render(<IntellijThemesDialogHost />);+ act(() => showInstalledIntellijThemes());+ expect(await screen.findByText(/No theme plugins found/)).toBeInTheDocument();+ expect(screen.getByRole("button", { name: "Import" })).toBeDisabled();+ await user.click(screen.getByRole("button", { name: "Choose File…" }));+ await waitFor(() => expect(read).toHaveBeenCalledWith("/downloads/DeepSea.jar"));+ expect(pick).toHaveBeenCalledOnce();+ });+});diff --git a/src/features/plugins/__tests__/plugins.test.tsx b/src/features/plugins/__tests__/plugins.test.tsxindex 8bafe2f67..ad701931c 100644--- a/src/features/plugins/__tests__/plugins.test.tsx+++ b/src/features/plugins/__tests__/plugins.test.tsx@@ -3,19 +3,21 @@ import { act, render, screen, waitFor, within } from "@testing-library/react";import userEvent from "@testing-library/user-event";import { EditorSelection, EditorState } from "@codemirror/state";import { EditorView } from "@codemirror/view";-import type { PluginInfo } from "@/bindings";+import type { PluginInfo, ProjectInfo } from "@/bindings";import { _setActiveEditor } from "@/editor/api";import { executeAction, executeActionFrom, getAction, registerAction } from "@/platform/actions";import { useProject } from "@/platform/project";-import { useContributedIconThemes } from "@/platform/themes";+import { pluginThemeRef, useContributedIconThemes } from "@/platform/themes";+import { ContextMenuHost, hideContextMenu } from "@/ui";import { provideNotificationService, type NotificationService } from "@/workbench/contributions";-import { applyThemeAttributes, useThemeOverride } from "@/workbench/theme";+import { applyThemeAttributes, previewTheme, useThemeOverride } from "@/workbench/theme";import { createMemoryPluginsBackend, sampleCatalog, setPluginsBackend, type PluginsBackend } from "../backend";import {applyPluginTheme,followThemeSetting,PLUGIN_THEME_STYLE_ID,handlePluginEvent,+ providePluginThemePreviews,pluginActionId,startPluginBridge,syncProjection,@@ -389,6 +391,36 @@ describe("bridge events", () => {useThemeOverride.setState({ theme: null });});+ it("previews a live plugin's theme in this window without selecting it", () => {+ const root = document.documentElement;+ const sheet = () => document.getElementById(PLUGIN_THEME_STYLE_ID)?.textContent ?? null;+ const setTheme = vi.spyOn(backend, "setTheme");+ const night = { id: "night", name: "Night", kind: "dark", tokens: { "--bg-app": "#101820" } };+ const dawn = { id: "dawn", name: "Dawn", kind: "light" as const, tokens: { "--bg-app": "#fff8e7" } };+ usePlugins.setState({+ ui: [{ pluginId: "acme", point: "themes", key: "night", decl: night }],+ activeTheme: { pluginId: "acme", theme: dawn },+ });+ applyPluginTheme(usePlugins.getState().activeTheme);+ const stop = providePluginThemePreviews();++ previewTheme(pluginThemeRef("acme", "night"));+ expect(sheet()).toContain("--bg-app: #101820;");+ expect([root.dataset.pluginTheme, root.dataset.theme]).toEqual(["acme/night", "dark"]);+ // A built-in theme shows without the plugin's tokens.+ previewTheme("solarized-light");+ expect(sheet()).toBeNull();+ expect([root.dataset.theme, root.dataset.colorTheme]).toEqual(["light", "solarized-light"]);+ // Back to the selected one; nothing was selected on the way.+ previewTheme(null);+ expect(sheet()).toContain("--bg-app: #fff8e7;");+ expect(root.dataset.pluginTheme).toBe("acme/dawn");+ expect(setTheme).not.toHaveBeenCalled();++ stop();+ applyPluginTheme(null);+ });+it("runs commands with the focused editor's path, language and UTF-16 selections", async () => {const calls: unknown[] = [];setPluginsBackend({@@ -464,6 +496,32 @@ describe("PluginsPage", () => {expect(screen.getByText("Toy (.toy)")).toBeInTheDocument();});+ it("offers the IntelliJ theme imports only in a trusted project's window", async () => {+ const user = userEvent.setup();+ render(+ <>+ <PluginsPage />+ <ContextMenuHost />+ </>,+ );+ const imports = async () => {+ await user.click(screen.getByRole("button", { name: "Manage Plugins" }));+ const found = ["Import Theme from IntelliJ IDE…", "Import IntelliJ Theme from File…"].filter((name) =>+ screen.queryByRole("menuitem", { name }),+ );+ act(() => hideContextMenu());+ return found;+ };+ // The welcome screen: the host refuses installs without a trusted project.+ expect(await imports()).toEqual([]);+ const project = { trusted: false, root: "/p", name: "p", isGit: false } as unknown as ProjectInfo;+ act(() => useProject.setState({ project }));+ expect(await imports()).toEqual([]);+ act(() => useProject.setState({ project: { ...project, trusted: true } }));+ expect(await imports()).toHaveLength(2);+ act(() => useProject.setState({ project: null }));+ });+it("restarts a failed plugin instead of disabling it", async () => {setPluginsBackend(createMemoryPluginsBackend([plugin({ id: "broken", status: "failed", error: "trap" })]));const user = userEvent.setup();diff --git a/src/features/plugins/backend.ts b/src/features/plugins/backend.tsindex 4d79330e2..8593c3a33 100644--- a/src/features/plugins/backend.ts+++ b/src/features/plugins/backend.ts@@ -10,7 +10,9 @@ import type {CatalogPlugin,Consent,EventKind,+ InstalledIntellijTheme,InstallPreview,+ IntellijThemeSource,MarketPlugin,PluginEditor,PluginEvent,@@ -71,6 +73,14 @@ export interface PluginsBackend {rollBack(id: string): Promise<PluginInfo>;/** File picker for a package: an `.oiplugin`, a `.zip` or a folder's `plugin.toml`; `null` when cancelled. */pickPackage(): Promise<string | null>;+ /** File picker for an IntelliJ theme plugin (`.jar`, `.zip`) or `.theme.json`; `null` when cancelled. */+ pickIntellijTheme(): Promise<string | null>;+ /** Reads the themes of an IntelliJ theme plugin or `.theme.json`. */+ readIntellijTheme(path: string): Promise<IntellijThemeSource>;+ /** Theme plugins installed in the JetBrains IDEs on this machine, the ones in use first. */+ installedIntellijThemes(): Promise<InstalledIntellijTheme[]>;+ /** Writes a generated package (`name`: its id); the folder to install from. */+ stagePackage(name: string, files: { path: string; text: string }[]): Promise<string>;/** Content of a plugin view (`doc`: the document of a custom editor). */renderView(pluginId: string, view: string, viewport: Viewport | null, doc: number | null): Promise<View>;viewEvent(pluginId: string, view: string, event: ViewEvent, doc: number | null): Promise<void>;@@ -166,6 +176,18 @@ export const tauriPluginsBackend: PluginsBackend = {});return (Array.isArray(picked) ? picked[0] : picked) ?? null;},+ pickIntellijTheme: async () => {+ const { open } = await import("@tauri-apps/plugin-dialog");+ const picked = await open({+ multiple: false,+ title: tx("Import IntelliJ Theme"),+ filters: [{ name: tx("IntelliJ theme plugin or theme file"), extensions: ["jar", "zip", "json"] }],+ });+ return (Array.isArray(picked) ? picked[0] : picked) ?? null;+ },+ readIntellijTheme: (path) => call(commands.pluginReadIntellijTheme(path)),+ installedIntellijThemes: () => call(commands.pluginInstalledIntellijThemes()),+ stagePackage: (name, files) => call(commands.pluginStagePackage(name, files)),// A tool window's calls (no `doc`) carry the window's active editor.renderView: (pluginId, view, viewport, doc) =>call(commands.pluginViewRender(pluginId, view, viewport, doc, doc == null ? editorContext() : null)),@@ -488,6 +510,14 @@ export function createMemoryPluginsBackend(throw new IpcError({ kind: "notFound", message: `${id} has no earlier version to roll back to` });},pickPackage: async () => null,+ pickIntellijTheme: async () => null,+ readIntellijTheme: async (path) => {+ throw new IpcError({ kind: "unavailable", message: `reading ${path} requires the desktop app` });+ },+ installedIntellijThemes: async () => [],+ stagePackage: async () => {+ throw new IpcError({ kind: "unavailable", message: "installing a generated plugin requires the desktop app" });+ },renderView: async (pluginId, view) => ({toolbar: [],body: { kind: "message", value: `${pluginId} · ${view} (plugin views need the desktop app)` },diff --git a/src/features/plugins/bridge.ts b/src/features/plugins/bridge.tsindex 9e4d06af7..8dc89b077 100644--- a/src/features/plugins/bridge.ts+++ b/src/features/plugins/bridge.ts@@ -12,7 +12,12 @@ import { refreshLanguageInfos } from "@/editor/core/cm/languages";import { notifications } from "@/workbench/contributions";import { useProducerNames } from "@/platform/inspections";import { languageListChanged } from "@/platform/languageList";-import { isThemeAvailable, parsePluginThemeRef, useContributedThemes } from "@/platform/themes";+import {+ isThemeAvailable,+ parsePluginThemeRef,+ providePluginThemePreview,+ useContributedThemes,+} from "@/platform/themes";import {applyThemeAttributes,currentThemeChoice,@@ -92,6 +97,22 @@ export function applyPluginTheme(theme: ActiveTheme | null, root: HTMLElement =if (had || theme) syncWindowBackground();}+/**+ * Quick Switch's theme preview of plugin themes: a live plugin's theme as it+ * contributes it, shown in this window only; nothing is selected or saved.+ */+export function providePluginThemePreviews(): () => void {+ return providePluginThemePreview((ref) => {+ const state = usePlugins.getState();+ if (ref === "selected") return applyPluginTheme(state.activeTheme);+ const want = ref ? parsePluginThemeRef(ref) : null;+ const item = want+ ? state.ui.find((c) => c.point === "themes" && c.pluginId === want.pluginId && c.key === want.themeId)+ : undefined;+ applyPluginTheme(item ? { pluginId: item.pluginId, theme: item.decl as ActiveTheme["theme"] } : null);+ });+}+/** localStorage key read by public/boot.js: the selected theme's stylesheet, applied before the app loads. */export const PLUGIN_THEME_CACHE_KEY = "openidea.pluginTheme";diff --git a/src/features/plugins/index.ts b/src/features/plugins/index.tsindex 3991847bf..9a90df93b 100644--- a/src/features/plugins/index.ts+++ b/src/features/plugins/index.ts@@ -5,6 +5,8 @@* projected by `projection.ts` / `points.tsx`.** Actions: `plugins.settings`, `plugins.installFromDisk`, `plugins.reloadAll`,+ * `plugins.importIntellijTheme` (a theme plugin file; `arg`: its path),+ * `plugins.importInstalledIntellijTheme` (from the JetBrains IDEs on this machine),* plus one action per plugin command: `plugin.<pluginId>.<commandId>`* (searchable in Search Everywhere › Actions and bindable in the keymap editor;* a string arg is forwarded to the plugin).@@ -17,12 +19,20 @@ import { lazyComponent } from "@/ui";import { executeAction, registerActions } from "@/platform/actions";import { useProject } from "@/platform/project";import { editorService, registerOverlay, registerSettingsPage } from "@/workbench/contributions";-import { followPluginChanges, startPluginBridge, syncProjection, trackPluginTheme } from "./bridge";+import {+ followPluginChanges,+ providePluginThemePreviews,+ startPluginBridge,+ syncProjection,+ trackPluginTheme,+} from "./bridge";import { ConsentDialogHost, provideConsentDialog } from "./consent";import { trackIconTheme } from "./iconThemes";import { pluginLineMarkerGutter } from "./lineMarkerGutter";import { defineBuiltinUiPoints } from "./points";import { startViewUi } from "./uiPoints";+import { importIntellijTheme, showInstalledIntellijThemes } from "./intellijImport";+import { IntellijThemesDialogHost } from "./IntellijThemesDialog";import { installFromDisk, refreshPlugins, reloadPlugin, SETTINGS_PAGE_ID, usePlugins } from "./store";function registerPluginsPage(): () => void {@@ -41,6 +51,7 @@ export function activateSettingsPages(): () => void {const disposers = [registerPluginsPage(),registerOverlay({ id: "plugins.consent", component: ConsentDialogHost }),+ registerOverlay({ id: "plugins.intellijThemes", component: IntellijThemesDialogHost }),provideConsentDialog(),defineBuiltinUiPoints(),followPluginChanges(),@@ -56,7 +67,9 @@ export function activate(): () => void {const disposers = [registerPluginsPage(),registerOverlay({ id: "plugins.consent", component: ConsentDialogHost }),+ registerOverlay({ id: "plugins.intellijThemes", component: IntellijThemesDialogHost }),provideConsentDialog(),+ providePluginThemePreviews(),registerActions([{id: "plugins.settings",@@ -76,6 +89,27 @@ export function activate(): () => void {await installFromDisk(typeof arg === "string" ? arg : undefined);},},+ {+ id: "plugins.importIntellijTheme",+ title: "Import IntelliJ Theme from File…",+ category: "Plugins",+ icon: "plugin",+ keywords: ["intellij", "jetbrains", "theme", "jar", "theme.json", "color scheme"],+ // Installing needs a project's window.+ when: "projectOpen",+ run: async ({ arg }) => {+ await importIntellijTheme(typeof arg === "string" ? arg : undefined);+ },+ },+ {+ id: "plugins.importInstalledIntellijTheme",+ title: "Import Theme from IntelliJ IDE…",+ category: "Plugins",+ icon: "plugin",+ keywords: ["intellij", "jetbrains", "theme", "color scheme", "migrate"],+ when: "projectOpen",+ run: () => showInstalledIntellijThemes(),+ },{id: "plugins.reloadAll",title: "Reload Plugins",diff --git a/src/features/plugins/intellijImport.ts b/src/features/plugins/intellijImport.tsnew file mode 100644index 000000000..3ba281f78--- /dev/null+++ b/src/features/plugins/intellijImport.ts@@ -0,0 +1,61 @@+/**+ * Settings › Plugins › Import IntelliJ Theme: an IntelliJ theme plugin (a+ * Marketplace `.jar` / `.zip`, a plugin folder of an installed IDE) or a+ * `.theme.json` becomes an OpenIDEA theme plugin — read by the host, converted+ * here (`intellijTheme.ts`), installed through the usual install page — and+ * its theme is applied.+ */+import { create } from "zustand";+import { pluginThemeRef } from "@/platform/themes";+import { notifications } from "@/workbench/contributions";+import { setTheme } from "@/workbench/theme";+import { pluginsBackend } from "./backend";+import { intellijThemePackage, type ThemePackage } from "./intellijTheme";+import { errorText, installFromDisk } from "./store";++/**+ * Imports the IntelliJ theme plugin at `path` (asks for a file without one)+ * and applies its theme `themeId` (an IntelliJ theme id), or its first.+ * Returns the installed plugin's id.+ */+export async function importIntellijTheme(path?: string, themeId?: string): Promise<string | null> {+ const backend = pluginsBackend();+ let pkg: ThemePackage;+ let dir: string;+ try {+ const picked = path ?? (await backend.pickIntellijTheme());+ if (!picked) return null;+ pkg = intellijThemePackage(await backend.readIntellijTheme(picked));+ dir = await backend.stagePackage(pkg.id, pkg.files);+ } catch (e) {+ notifications().notify({+ group: "plugins",+ level: "error",+ title: "Could not import the IntelliJ theme",+ body: errorText(e),+ });+ return null;+ }+ const id = await installFromDisk(dir);+ if (!id) return null;+ const theme = pkg.themes.find((t) => t.sourceId === themeId) ?? pkg.themes[0];+ if (theme) await setTheme(pluginThemeRef(id, theme.id));+ return id;+}++interface DialogState {+ open: boolean;+ /** Called with the plugin id after an import from the dialog. */+ onImported: ((id: string) => void) | null;+}++export const useIntellijThemesDialog = create<DialogState>(() => ({ open: false, onImported: null }));++/** Shows the themes of the JetBrains IDEs on this machine to pick one to import. */+export function showInstalledIntellijThemes(onImported?: (id: string) => void): void {+ useIntellijThemesDialog.setState({ open: true, onImported: onImported ?? null });+}++export function closeInstalledIntellijThemes(): void {+ useIntellijThemesDialog.setState({ open: false, onImported: null });+}diff --git a/scripts/theme/intellij.ts b/src/features/plugins/intellijTheme.tssimilarity index 76%rename from scripts/theme/intellij.tsrename to src/features/plugins/intellijTheme.tsindex 407f2ca06..b1e81364d 100644--- a/scripts/theme/intellij.ts+++ b/src/features/plugins/intellijTheme.ts@@ -1,11 +1,13 @@/*** Converts an IntelliJ theme (`.theme.json`, optionally with its editor scheme- * `.icls`) into an OpenIDEA theme + editor scheme. The mapping covers the- * main keys only; anything unmapped keeps the built-in value of the base- * (`kind`). Pure functions, no dependencies: see import-intellij-theme.ts- * for the command line.+ * `.icls`) into an OpenIDEA theme + editor scheme, and an IntelliJ theme+ * plugin into an OpenIDEA theme plugin package. The mapping covers the main+ * keys only; anything unmapped keeps the built-in value of the base (`kind`).+ *+ * Pure functions without imports: Settings › Plugins › Import IntelliJ Theme+ * uses them on what the host read from the plugin (`plugin_read_intellij_theme`),+ * and so does the command line (`scripts/theme/import-intellij-theme.ts`).*/-import { stripJsonComments } from "./tokens.ts";/** OpenIDEA token ← IntelliJ `ui` keys, first present wins. `*.prop` wildcards apply too. */export const UI_KEYS: Record<string, string[]> = {@@ -272,9 +274,11 @@ export function slug(name: string): string {);}-/** Converts an IntelliJ `.theme.json` (and optionally its `.icls`) into OpenIDEA theme files. */+/** Converts an IntelliJ `.theme.json` (comments removed) and optionally its `.icls` into OpenIDEA theme files. */export function convertIntellijTheme(themeJson: string, icls?: string, id?: string): ConvertedTheme {- const src = JSON.parse(stripJsonComments(themeJson)) as { [k: string]: Json };+ const parsed = JSON.parse(themeJson) as Json;+ if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Not an IntelliJ theme");+ const src = parsed;const name = typeof src.name === "string" ? src.name : "Imported Theme";const named = new Map<string, string>();if (src.colors && typeof src.colors === "object" && !Array.isArray(src.colors)) {@@ -307,21 +311,104 @@ export function convertIntellijTheme(themeJson: string, icls?: string, id?: stri};}-/** `plugin.toml` for a converted theme. */-export function pluginManifest(c: ConvertedTheme, author: string, sourceName: string): string {- const q = (s: string) => JSON.stringify(s);+/** A TOML basic string: quotes, backslashes and control characters escaped, lone surrogates replaced. */+function tomlString(s: string): string {+ let body = "";+ for (const ch of s) {+ const code = ch.codePointAt(0)!;+ if (ch === '"' || ch === "\\") body += `\\${ch}`;+ else if (code < 0x20 || code === 0x7f) body += `\\u${code.toString(16).padStart(4, "0")}`;+ // `for…of` pairs surrogates, so one in this range is alone.+ else if (code >= 0xd800 && code <= 0xdfff) body += "�";+ else body += ch;+ }+ return `"${body}"`;+}++export interface ThemePackageInfo {+ id: string;+ name: string;+ version: string;+ description: string;+ authors: string[];+}++/** `plugin.toml` for converted themes, each at `themes/<id>.theme.json` (+ `.scheme.json`). */+export function pluginManifest(info: ThemePackageInfo, themes: readonly ConvertedTheme[], comment?: string): string {return [- `# Converted from ${sourceName} by scripts/theme/import-intellij-theme.ts.`,- `id = ${q(`theme-${c.theme.id}`)}`,- `name = ${q(`${c.theme.name} Theme`)}`,- `version = "1.0.0"`,- `description = ${q(`${c.theme.name}, converted from an IntelliJ theme.`)}`,- `authors = [${q(author)}]`,- `openidea-api = "0.1"`,- "",- "[[contributes.themes]]",- `path = ${q(`themes/${c.theme.id}.theme.json`)}`,- ...(c.scheme ? [`editor-scheme = ${q(`themes/${c.theme.id}.scheme.json`)}`] : []),+ ...(comment ? [`# ${comment.replace(/[\r\n]+/g, " ")}`] : []),+ `id = ${tomlString(info.id)}`,+ `name = ${tomlString(info.name)}`,+ `version = ${tomlString(info.version)}`,+ `description = ${tomlString(info.description)}`,+ `authors = [${info.authors.map(tomlString).join(", ")}]`,+ `engines.openidea = "^1.0"`,+ ...themes.flatMap((c) => [+ "",+ "[[contributes.themes]]",+ `path = ${tomlString(`themes/${c.theme.id}.theme.json`)}`,+ ...(c.scheme ? [`editor-scheme = ${tomlString(`themes/${c.theme.id}.scheme.json`)}`] : []),+ ]),"",].join("\n");}++/** An IntelliJ theme plugin as the host read it (`IntellijThemeSource`). */+export interface IntellijThemeSource {+ name: string;+ pluginId: string | null;+ version: string | null;+ vendor: string | null;+ themes: { id: string; theme: string; editorScheme: string | null }[];+}++export interface ThemePackage {+ id: string;+ name: string;+ files: { path: string; text: string }[];+ /** The package's themes: their id here and in the IntelliJ plugin (`sourceId`). */+ themes: { id: string; sourceId: string; name: string }[];+}++/** `2.3` → `2.3.0`; IntelliJ plugin versions are not always semver. */+function semver(version: string | null): string {+ const m = /^\s*v?(\d{1,9})(?:\.(\d{1,9}))?(?:\.(\d{1,9}))?/.exec(version ?? "");+ return m ? `${Number(m[1])}.${Number(m[2] ?? 0)}.${Number(m[3] ?? 0)}` : "1.0.0";+}++/** An OpenIDEA theme plugin (`intellij.<plugin>`) with every theme of an IntelliJ theme plugin. */+export function intellijThemePackage(source: IntellijThemeSource): ThemePackage {+ const ids = new Set<string>();+ const converted = source.themes.map((t) => {+ const c = convertIntellijTheme(t.theme, t.editorScheme ?? undefined);+ let id = c.theme.id;+ for (let n = 2; ids.has(id); n++) id = `${c.theme.id.slice(0, 44)}-${n}`;+ ids.add(id);+ c.theme.id = id;+ return { sourceId: t.id, converted: c };+ });+ if (converted.length === 0) throw new Error("The plugin has no themes");+ const themes = converted.map((c) => c.converted);+ // Package metadata, not UI text: the plugin list shows it as written.+ const description = `${source.name}, imported from an IntelliJ theme plugin.`;+ const info: ThemePackageInfo = {+ id: `intellij.${slug(source.pluginId ?? source.name)}`,+ name: source.name,+ version: semver(source.version),+ description,+ authors: source.vendor ? [source.vendor] : [],+ };+ const json = (value: unknown) => `${JSON.stringify(value, null, 2)}\n`;+ return {+ id: info.id,+ name: info.name,+ files: [+ { path: "plugin.toml", text: pluginManifest(info, themes) },+ ...themes.flatMap((c) => [+ { path: `themes/${c.theme.id}.theme.json`, text: json(c.theme) },+ ...(c.scheme ? [{ path: `themes/${c.theme.id}.scheme.json`, text: json(c.scheme) }] : []),+ ]),+ ],+ themes: converted.map(({ sourceId, converted: c }) => ({ id: c.theme.id, sourceId, name: c.theme.name })),+ };+}diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex d9b32f770..8bf614a02 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -5776,6 +5776,21 @@"Unsigned": "未签名","Roll Back to {previousVersion}": "回滚到 {previousVersion}","Install Plugin from Package File…": "从插件包文件安装…",+ "Import Theme from IntelliJ IDE…": "从 IntelliJ IDE 导入主题…",+ "Import IntelliJ Theme from File…": "从文件导入 IntelliJ 主题…",+ "Import Theme from IntelliJ IDE": "从 IntelliJ IDE 导入主题",+ "Import IntelliJ Theme": "导入 IntelliJ 主题",+ "IntelliJ theme plugin or theme file": "IntelliJ 主题插件或主题文件",+ "Could not import the IntelliJ theme": "无法导入 IntelliJ 主题",+ "Import": "导入",+ "In use": "使用中",+ "IntelliJ themes": "IntelliJ 主题",+ "Looking for IntelliJ themes": "正在查找 IntelliJ 主题",+ "Looking for IntelliJ themes…": "正在查找 IntelliJ 主题…",+ "Theme plugins installed in the JetBrains IDEs on this computer. Importing a theme brings every theme of its plugin and applies the chosen one. Colours without an OpenIDEA counterpart keep the default theme colours.": "此计算机上 JetBrains IDE 中安装的主题插件。导入某个主题会一并导入其插件的全部主题,并应用所选主题。没有对应 OpenIDEA 颜色的项保留默认主题的颜色。",+ "1 theme": "1 个主题",+ "{count} themes": "{count} 个主题",+ "No theme plugins found in JetBrains IDEs on this computer. Choose a theme plugin downloaded from the JetBrains Marketplace (.jar or .zip) or a .theme.json file instead.": "在此计算机上的 JetBrains IDE 中未找到主题插件。请改为选择从 JetBrains Marketplace 下载的主题插件(.jar 或 .zip)或 .theme.json 文件。","Marketplace index URL": "插件市场索引 URL","Refresh Marketplace": "刷新插件市场","Marketplace": "插件市场",diff --git a/src/platform/themes.test.ts b/src/platform/themes.test.tsindex d8df8716a..d8d332fe9 100644--- a/src/platform/themes.test.ts+++ b/src/platform/themes.test.ts@@ -8,6 +8,7 @@ import {parsePluginThemeRef,pluginThemeRef,themeChoices,+ themeGroups,themeKind,useContributedThemes,} from "./themes";@@ -19,6 +20,7 @@ import {resolveThemeId,themeSelectOptions,} from "@/workbench/theme";+import { themeItems } from "@/workbench/quickSwitch";import { validateSettings } from "@/features/settings/model/schema";import { applyPluginTheme } from "@/features/plugins/bridge";@@ -108,7 +110,10 @@ describe("plugin themes", () => {const remove = addContributedTheme({ id: ref, label: "Night", kind: "dark", origin: "Acme" });expect(isThemeAvailable(ref)).toBe(true);expect(themeChoices().at(-1)).toMatchObject({ id: ref, label: "Night" });- expect(themeSelectOptions(themeChoices(), ref).at(-1)).toEqual({ value: ref, label: "Night", detail: "Acme" });+ expect(themeSelectOptions(themeChoices(), ref).slice(-2)).toEqual([+ { value: "plugin:acme.night", label: "Acme", section: true },+ { value: ref, label: "Night" },+ ]);// Its tokens apply over the default of its kind.expect(resolveThemeId(a, false)).toBe("dark");@@ -116,7 +121,55 @@ describe("plugin themes", () => {expect(isThemeAvailable(ref)).toBe(false);// Its plugin off: the base of the kind it had shows, and the pickers keep it listed.expect(resolveThemeId(a, false)).toBe("dark");- expect(themeSelectOptions(themeChoices(), ref).at(-1)).toMatchObject({ value: ref, label: "night" });+ expect(themeSelectOptions(themeChoices(), ref).slice(-2)).toMatchObject([+ { value: "plugin:acme.night", label: "acme.night", section: true },+ { value: ref, label: "night", detail: "Plugin not enabled" },+ ]);+ // Its plugin live but the theme gone (an update dropped it): listed under that plugin's heading.+ const stay = addContributedTheme({+ id: pluginThemeRef("acme.night", "dawn"),+ label: "Dawn",+ kind: "dark",+ origin: "Acme",+ });+ addContributedTheme({ id: pluginThemeRef("zeta.blue", "blue"), label: "Blue", kind: "dark", origin: "Zeta" });+ expect(+ themeSelectOptions(themeChoices(), ref)+ .slice(BUILTIN_THEMES.length)+ .map((o) => (o.section ? `[${o.label}]` : o.label)),+ ).toEqual(["[Acme]", "Dawn", "night", "[Zeta]", "Blue"]);+ stay();+ });++ it("are grouped by plugin: the built-in ones first, then each plugin's by name", () => {+ const theme = (plugin: string, id: string, label: string, origin: string) =>+ addContributedTheme({ id: pluginThemeRef(plugin, id), label, kind: "dark", origin });+ theme("intellij.dracula", "dracula", "Dracula", "Dracula Theme");+ theme("acme.night", "night", "Night", "Acme");+ theme("intellij.dracula", "alucard", "Dracula Alucard", "Dracula Theme");+ theme("acme.night", "dawn", "Dawn", "Acme");++ const groups = themeGroups();+ expect(groups.map((g) => [g.origin, g.themes.map((t) => t.label)])).toEqual([+ [undefined, BUILTIN_THEMES.map((t) => t.label)],+ ["Acme", ["Dawn", "Night"]],+ ["Dracula Theme", ["Dracula", "Dracula Alucard"]],+ ]);+ expect(themeChoices().map((t) => t.label)).toEqual(groups.flatMap((g) => g.themes.map((t) => t.label)));++ // Menus draw a line between the groups, as IDEA's Theme list.+ const items = themeItems("light");+ const lines = items.flatMap((item, i) => (item.kind === "separator" ? [i] : []));+ expect(lines).toEqual([BUILTIN_THEMES.length, BUILTIN_THEMES.length + 3]);+ expect(items.find((i) => i.kind !== "separator" && "checked" in i && i.checked)).toMatchObject({+ label: "Islands Light",+ });+ // Selects head each plugin's themes with its name.+ expect(+ themeSelectOptions(themeChoices())+ .slice(BUILTIN_THEMES.length)+ .map((o) => (o.section ? `[${o.label}]` : o.label)),+ ).toEqual(["[Acme]", "Dawn", "Night", "[Dracula Theme]", "Dracula", "Dracula Alucard"]);});it("parse only well-formed references", () => {diff --git a/src/platform/themes.ts b/src/platform/themes.tsindex 3454f8937..4fd4ff746 100644--- a/src/platform/themes.ts+++ b/src/platform/themes.ts@@ -77,11 +77,58 @@ export function addContributedTheme(theme: ThemeChoice): () => void {return () => useContributedThemes.setState((s) => ({ themes: s.themes.filter((t) => t !== theme) }));}-/** Every theme that can be selected: the built-in ones, then the contributed ones by name. */+/** Themes of one origin: the built-in ones, or one plugin's. */+export interface ThemeGroup {+ /** The contributing plugin; none for the built-in themes. */+ pluginId?: string;+ /** The plugin's name. */+ origin?: string;+ themes: ThemeChoice[];+}++/** The selectable themes by origin: the built-in ones, then each plugin's by its name, themes by name. */+export function themeGroups(+ contributed: readonly ThemeChoice[] = useContributedThemes.getState().themes,+): ThemeGroup[] {+ const plugins = new Map<string, ThemeGroup>();+ for (const theme of contributed) {+ const pluginId = parsePluginThemeRef(theme.id)?.pluginId ?? "";+ const group = plugins.get(pluginId) ?? { pluginId, origin: theme.origin, themes: [] };+ plugins.set(pluginId, group);+ group.themes.push(theme);+ }+ const name = (g: ThemeGroup) => g.origin ?? g.pluginId ?? "";+ const groups = [...plugins.values()].sort(+ (a, b) => name(a).localeCompare(name(b)) || (a.pluginId ?? "").localeCompare(b.pluginId ?? ""),+ );+ for (const group of groups) group.themes.sort((a, b) => a.label.localeCompare(b.label));+ return [{ themes: [...BUILTIN_THEMES] }, ...groups];+}++/** Every theme that can be selected, in the order of `themeGroups`. */export function themeChoices(contributed: readonly ThemeChoice[] = useContributedThemes.getState().themes,): ThemeChoice[] {- return [...BUILTIN_THEMES, ...[...contributed].sort((a, b) => a.label.localeCompare(b.label))];+ return themeGroups(contributed).flatMap((g) => g.themes);+}++/**+ * Shows a plugin theme in this window without selecting it, `null` none, or+ * `"selected"` the one selected again. The plugins feature provides it.+ */+export type PluginThemePreview = (theme: PluginThemeRef | null | "selected") => void;++let pluginThemePreview: PluginThemePreview | null = null;++export function providePluginThemePreview(preview: PluginThemePreview): () => void {+ pluginThemePreview = preview;+ return () => {+ if (pluginThemePreview === preview) pluginThemePreview = null;+ };+}++export function previewPluginTheme(theme: PluginThemeRef | null | "selected"): void {+ pluginThemePreview?.(theme);}/** Whether `id` can be applied now (a contributed theme's plugin may be off). */diff --git a/src/ui/Menu.tsx b/src/ui/Menu.tsxindex be637b6b6..74ef0dcc7 100644--- a/src/ui/Menu.tsx+++ b/src/ui/Menu.tsx@@ -45,6 +45,8 @@ export type MenuItem =checked?: boolean;danger?: boolean;run?: () => void;+ /** The pointer or the keyboard made it the active item (not on opening the menu). */+ onActive?: () => void;submenu?: MenuItem[];};@@ -58,6 +60,7 @@ interface Resolved {checked?: boolean;danger?: boolean;run?: () => void;+ onActive?: () => void;submenu?: MenuItem[];}@@ -132,6 +135,11 @@ export function MenuList({ items, onDone, onCloseLevel, autoFocusFirst = true, .}, [active, openSub]);useEffect(() => () => clearTimeout(hoverTimer.current), []);+ const focusItem = (i: number) => {+ setActive(i);+ resolved[i]?.onActive?.();+ };+const move = (delta: number, from = active) => {const n = resolved.length;if (!n) return;@@ -139,7 +147,7 @@ export function MenuList({ items, onDone, onCloseLevel, autoFocusFirst = true, .for (let step = 0; step < n; step++) {i = (i + delta + n) % n;if (selectable(resolved[i])) {- setActive(i);+ focusItem(i);return;}}@@ -191,7 +199,7 @@ export function MenuList({ items, onDone, onCloseLevel, autoFocusFirst = true, .const i = (active + s + n) % n;const r = resolved[i]!;if (selectable(r) && r.label.toLowerCase().startsWith(ch)) {- setActive(i);+ focusItem(i);break;}}@@ -235,7 +243,7 @@ export function MenuList({ items, onDone, onCloseLevel, autoFocusFirst = true, .)}onPointerEnter={() => {if (r.disabled) return;- setActive(i);+ focusItem(i);clearTimeout(hoverTimer.current);hoverTimer.current = setTimeout(() => setOpenSub(hasSub ? i : null), hasSub ? 120 : 200);}}diff --git a/src/workbench/quickSwitch.test.tsx b/src/workbench/quickSwitch.test.tsxnew file mode 100644index 000000000..9d5c7d10c--- /dev/null+++ b/src/workbench/quickSwitch.test.tsx@@ -0,0 +1,116 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { act, fireEvent, render, screen } from "@testing-library/react";+import { ContextMenuHost, hideContextMenu, MenuList } from "@/ui";+import { showQuickSwitch, THEME_PREVIEW_DELAY, themePreview } from "./quickSwitch";+import {+ applyThemeAttributes,+ currentThemeId,+ STARTUP_THEME_KEY,+ syncWindowBackground,+ useThemeOverride,+} from "./theme";++const root = document.documentElement;+const shown = () => [root.dataset.theme, root.dataset.colorTheme ?? null];++beforeEach(() => {+ vi.useFakeTimers();+ useThemeOverride.setState({ theme: null });+ applyThemeAttributes(currentThemeId());+});++afterEach(() => {+ act(() => hideContextMenu());+ vi.useRealTimers();+ useThemeOverride.setState({ theme: null });+ applyThemeAttributes(currentThemeId());+});++describe("menu items", () => {+ it("report becoming active by pointer or keyboard, not on opening", () => {+ const active: string[] = [];+ const item = (label: string) => ({ label, onActive: () => active.push(label), run: () => {} });+ render(<MenuList items={[item("One"), item("Two"), item("Three")]} onDone={() => {}} />);+ expect(active).toEqual([]);+ fireEvent.keyDown(screen.getByRole("menu"), { key: "ArrowDown" });+ fireEvent.pointerEnter(screen.getByRole("menuitem", { name: "Three" }));+ fireEvent.keyDown(screen.getByRole("menu"), { key: "o" });+ expect(active).toEqual(["Two", "Three", "One"]);+ });+});++describe("Quick Switch theme preview", () => {+ it("shows the active theme after a moment, in this window only, and takes it back", () => {+ syncWindowBackground();+ const startup = localStorage.getItem(STARTUP_THEME_KEY);+ const before = shown();+ const preview = themePreview();+ preview.preview("solarized-dark");+ vi.advanceTimersByTime(THEME_PREVIEW_DELAY - 1);+ expect(shown()).toEqual(before);+ // Moving on restarts the delay: only the theme the user stays on shows.+ preview.preview("one-light");+ vi.advanceTimersByTime(THEME_PREVIEW_DELAY - 1);+ expect(shown()).toEqual(before);+ vi.advanceTimersByTime(1);+ expect(shown()).toEqual(["light", "one-light"]);+ // Nothing is selected or saved, not even as the next start-up's theme.+ expect(useThemeOverride.getState().theme).toBeNull();+ expect(localStorage.getItem(STARTUP_THEME_KEY)).toBe(startup);++ preview.restore();+ expect(shown()).toEqual(before);+ expect(localStorage.getItem(STARTUP_THEME_KEY)).toBe(startup);+ preview.preview("solarized-dark");+ vi.advanceTimersByTime(THEME_PREVIEW_DELAY);+ preview.end();+ expect(shown()).toEqual(before);+ });++ it("selects the chosen theme and keeps it when the menu closes", () => {+ const preview = themePreview();+ preview.preview("solarized-dark");+ vi.advanceTimersByTime(THEME_PREVIEW_DELAY);+ preview.choose("one-dark");+ expect(useThemeOverride.getState().theme).toBe("one-dark");+ expect(shown()).toEqual(["dark", "one-dark"]);+ preview.end();+ expect(shown()).toEqual(["dark", "one-dark"]);+ });++ it("previews from the Theme submenu and takes the preview back when the menu closes", async () => {+ const before = shown();+ render(<ContextMenuHost />);+ act(() => showQuickSwitch({ x: 10, y: 10 }));+ fireEvent.pointerEnter(screen.getByRole("menuitem", { name: "Theme" }));+ act(() => vi.advanceTimersByTime(200));+ fireEvent.pointerEnter(screen.getByRole("menuitemcheckbox", { name: "Solarized Light" }));+ act(() => vi.advanceTimersByTime(THEME_PREVIEW_DELAY));+ expect(shown()).toEqual(["light", "solarized-light"]);++ // Back on another entry: the selected theme again.+ fireEvent.pointerEnter(screen.getByRole("menuitem", { name: "Keymap" }));+ expect(shown()).toEqual(before);++ fireEvent.pointerEnter(screen.getByRole("menuitem", { name: "Theme" }));+ act(() => vi.advanceTimersByTime(200));+ fireEvent.pointerEnter(screen.getByRole("menuitemcheckbox", { name: "Solarized Light" }));+ act(() => vi.advanceTimersByTime(THEME_PREVIEW_DELAY));+ act(() => hideContextMenu());+ await act(async () => {});+ expect(shown()).toEqual(before);+ expect(useThemeOverride.getState().theme).toBeNull();+ });++ it("selects a theme clicked in the Theme submenu", async () => {+ render(<ContextMenuHost />);+ act(() => showQuickSwitch({ x: 10, y: 10 }));+ fireEvent.pointerEnter(screen.getByRole("menuitem", { name: "Theme" }));+ act(() => vi.advanceTimersByTime(200));+ fireEvent.click(screen.getByRole("menuitemcheckbox", { name: "Solarized Dark" }));+ await act(async () => {});+ expect(useThemeOverride.getState().theme).toBe("solarized-dark");+ expect(shown()).toEqual(["dark", "solarized-dark"]);+ expect(screen.queryByRole("menu")).toBeNull();+ });+});diff --git a/src/workbench/quickSwitch.ts b/src/workbench/quickSwitch.tsindex fb3d5039c..e45266b2e 100644--- a/src/workbench/quickSwitch.ts+++ b/src/workbench/quickSwitch.ts@@ -7,9 +7,9 @@ import { listSchemes } from "@/platform/colorScheme";import { editorPrefs } from "@/platform/editorSettings";import { PRESET_TITLES, useKeymap } from "@/platform/keymap";import { useProject } from "@/platform/project";-import type { MenuItem } from "@/ui";-import { themeChoices } from "@/platform/themes";-import { currentThemeChoice, setTheme } from "./theme";+import { showContextMenu, useContextMenuStore, type MenuItem } from "@/ui";+import { themeGroups, type ThemeChoiceId } from "@/platform/themes";+import { currentThemeChoice, previewTheme, setTheme } from "./theme";async function setGlobal(key: string, value: unknown, what: string) {if (!isTauri()) return;@@ -22,15 +22,67 @@ async function setGlobal(key: string, value: unknown, what: string) {export const selectKeymap = (id: string) => setGlobal("keymap", id, "keymap");-export function themeItems(themeId: string = currentThemeChoice()): MenuItem[] {- return themeChoices().map<MenuItem>((c) => ({- id: `theme.${c.id}`,- label: c.label,- // Plugin themes keep their own names.- verbatim: !!c.origin,- checked: c.id === themeId,- run: () => void setTheme(c.id),- }));+/** How long a theme stays under the pointer or keyboard before Quick Switch shows it (IDEA's delay). */+export const THEME_PREVIEW_DELAY = 500;++/**+ * IDEA's instant theme switch (`ide.instant.theme.switch`): in Quick Switch+ * the active theme shows after a moment, in this window only; choosing one+ * selects it, and closing the menu without a choice brings the selected+ * theme back.+ */+export interface ThemePreview {+ preview(id: ThemeChoiceId): void;+ /** Back to the selected theme (another Quick Switch entry became active). */+ restore(): void;+ choose(id: ThemeChoiceId): void;+ /** The menu closed. */+ end(): void;+}++export function themePreview(): ThemePreview {+ let timer: ReturnType<typeof setTimeout> | undefined;+ let shown: ThemeChoiceId | null = null;+ let chosen = false;+ const restore = () => {+ clearTimeout(timer);+ if (shown !== null && !chosen) previewTheme(null);+ shown = null;+ };+ return {+ preview(id) {+ clearTimeout(timer);+ timer = setTimeout(() => {+ shown = id;+ previewTheme(id);+ }, THEME_PREVIEW_DELAY);+ },+ restore,+ choose(id) {+ clearTimeout(timer);+ chosen = true;+ // Shown right away; selecting it then changes nothing visible.+ if (shown !== id) previewTheme(id);+ void setTheme(id);+ },+ end: restore,+ };+}++/** The built-in themes, then each plugin's, a separator between them (as IDEA's Theme list). */+export function themeItems(themeId: string = currentThemeChoice(), preview?: ThemePreview): MenuItem[] {+ return themeGroups().flatMap<MenuItem>((group, i) => [+ ...(i > 0 ? [{ kind: "separator" as const }] : []),+ ...group.themes.map<MenuItem>((c) => ({+ id: `theme.${c.id}`,+ label: c.label,+ // Plugin themes keep their own names.+ verbatim: !!c.origin,+ checked: c.id === themeId,+ onActive: preview && (() => preview.preview(c.id)),+ run: () => (preview ? preview.choose(c.id) : void setTheme(c.id)),+ })),+ ]);}export function keymapItems(keymapId: string, customKeymaps: string[]): MenuItem[] {@@ -78,17 +130,32 @@ export function keymapState(): { keymapId: string; customs: string[] } {};}-/** View › Quick Switch Scheme…: IDEA's popup of the switchable schemes. */-export function quickSwitchItems(): MenuItem[] {+/** View › Quick Switch Scheme…: IDEA's popup of the switchable schemes, its themes previewed. */+export function quickSwitchItems(preview?: ThemePreview): MenuItem[] {const { keymapId, customs } = keymapState();+ const restore = preview && (() => preview.restore());return [{id: "qs.scheme",label: "Editor Color Scheme",+ onActive: restore,submenu: colorSchemeItems(useProject.getState().settings?.editor?.colorScheme),},- { id: "qs.keymap", label: "Keymap", submenu: keymapItems(keymapId, customs) },- { id: "qs.viewMode", label: "View Mode", submenu: VIEW_MODE_ITEMS },- { id: "qs.theme", label: "Theme", submenu: themeItems() },+ { id: "qs.keymap", label: "Keymap", onActive: restore, submenu: keymapItems(keymapId, customs) },+ { id: "qs.viewMode", label: "View Mode", onActive: restore, submenu: VIEW_MODE_ITEMS },+ { id: "qs.theme", label: "Theme", submenu: themeItems(undefined, preview) },];}++/** Opens Quick Switch Scheme; a theme previewed there goes away with the menu unless chosen. */+export function showQuickSwitch(at: { x: number; y: number }) {+ const preview = themePreview();+ showContextMenu(at, quickSwitchItems(preview));+ const menu = useContextMenuStore.getState().menu;+ const unsubscribe = useContextMenuStore.subscribe((s) => {+ if (s.menu === menu) return;+ unsubscribe();+ // A chosen item runs right after the menu closes: let it choose first.+ queueMicrotask(() => preview.end());+ });+}diff --git a/src/workbench/shellActions.ts b/src/workbench/shellActions.tsindex 8ef0762d9..f12a5c770 100644--- a/src/workbench/shellActions.ts+++ b/src/workbench/shellActions.ts@@ -3,7 +3,7 @@ import { isTauri } from "@/platform/ipc";import { closeProject, confirmLeaveProject, openProject, useProject } from "@/platform/project";import { runSearchFieldCommand, showContextMenu } from "@/ui";import { showCustomizeToolbar } from "./MainToolbarDialog";-import { quickSwitchItems } from "./quickSwitch";+import { showQuickSwitch } from "./quickSwitch";import { notify } from "./notificationStore";import { NOTIFICATIONS_TOOL_WINDOW } from "./Notifications";import { activateToolWindow } from "./toolwindows/store";@@ -96,7 +96,7 @@ export function registerShellActions(): () => void {title: "Quick Switch Scheme…",category: "View",keywords: ["theme", "color scheme", "keymap", "view mode"],- run: () => showContextMenu({ x: window.innerWidth / 2 - 120, y: 96 }, quickSwitchItems()),+ run: () => showQuickSwitch({ x: window.innerWidth / 2 - 120, y: 96 }),},{id: "toolbar.customize",diff --git a/src/workbench/theme.ts b/src/workbench/theme.tsindex 44e73c786..e4559ad33 100644--- a/src/workbench/theme.ts+++ b/src/workbench/theme.ts@@ -6,8 +6,10 @@ import { call, commands, isTauri } from "@/platform/ipc";import { useProject } from "@/platform/project";import {baseTheme,+ isBuiltinTheme,isThemeChoiceId,parsePluginThemeRef,+ previewPluginTheme,themeChoices,themeKind,useContributedThemes,@@ -181,7 +183,7 @@ export function rememberStartupTheme(root: HTMLElement = document.documentElemen* for the next window's start-up.*/export function syncWindowBackground() {- rememberStartupTheme();+ if (!previewing) rememberStartupTheme();if (!isTauri()) return;const color = windowBackgroundColor();if (!color) return;@@ -231,6 +233,28 @@ export async function setTheme(next: ThemeSetting) {}}+/** A previewed theme is not the next start-up's (`rememberStartupTheme`). */+let previewing = false;++/**+ * Shows `id` in this window without selecting it (Quick Switch's instant+ * theme switch); `null` shows the selected theme again. Nothing is saved and+ * other windows keep theirs.+ */+export function previewTheme(id: ThemeChoiceId | null) {+ previewing = id !== null;+ if (id === null) {+ previewPluginTheme("selected");+ applyThemeAttributes(currentThemeId());+ } else if (isBuiltinTheme(id)) {+ previewPluginTheme(null);+ applyThemeAttributes(id);+ } else {+ previewPluginTheme(id);+ }+ syncWindowBackground();+}+export async function toggleTheme() {await setTheme(currentTheme() === "dark" ? "light" : "dark");}@@ -244,14 +268,30 @@ export function originDetail(t: { label: string; origin?: string }): string | un* Options for a theme picker: built-in themes, then plugins' (with the plugin* named beside them). A selected plugin theme whose plugin is off stays listed.*/+/** The themes for a picker: each plugin's under a heading with its name (`choices` in `themeGroups` order). */export function themeSelectOptions(choices: readonly ThemeChoice[], selected?: string): SelectOption<ThemeChoiceId>[] {- const options: SelectOption<ThemeChoiceId>[] = choices.map((c) => ({- value: c.id,- label: c.label,- detail: originDetail(c),- }));+ const options: SelectOption<ThemeChoiceId>[] = [];+ let group: string | undefined;+ for (const c of choices) {+ const pluginId = parsePluginThemeRef(c.id)?.pluginId;+ if (pluginId && pluginId !== group)+ options.push({ value: `plugin:${pluginId}`, label: c.origin ?? pluginId, section: true });+ group = pluginId;+ // Under its plugin's heading a theme needs no origin.+ options.push({ value: c.id, label: c.label });+ }const missing = parsePluginThemeRef(selected);- if (missing && !options.some((o) => o.value === selected))- options.push({ value: selected as ThemeChoiceId, label: missing.themeId, detail: "Plugin not enabled" });+ if (missing && !options.some((o) => o.value === selected)) {+ // Under its own plugin's heading, not the last one listed.+ const option = { value: selected as ThemeChoiceId, label: missing.themeId, detail: "Plugin not enabled" };+ const heading = options.findIndex((o) => o.section && o.value === `plugin:${missing.pluginId}`);+ if (heading < 0)+ options.push({ value: `plugin:${missing.pluginId}`, label: missing.pluginId, section: true }, option);+ else {+ let end = heading + 1;+ while (end < options.length && !options[end]!.section) end++;+ options.splice(end, 0, option);+ }+ }return options;}