Порівняти коміти

...
Автор SHA1 Повідомлення Дата
l0ng-ai 45d34ac638 fix(editor): keep indent guides in the indentation with a proportional font (#3634)
Guides were placed at multiples of ch (the width of "0"), while indentation is made of spaces, which are narrower in a proportional font, so guides drifted into the code the deeper the block. The guides plugin now measures the editor font's space width (--openidea-space) and places guides, and the indent of code lens rows, by it. Monospace fonts render as before.
2026-11-16 12:28:53 +08:00
LU XIANGRUIтаwildcatDownstairs 7709897dbb fix(project): ask about trust before opening the project window (#3663)
Opening an untrusted project in a new window created the window first and asked inside it, where the splash gave way after its 4 s limit to the Welcome screen under the question.

Entry points that may create a window (Open…, Open in New Window, recent projects, dropped folders, clone, plugin requests) now ask in the current window first and create the window only after Trust or Preview; Don't Open creates none. A launch without an originating window (openidea <path>, Dock drop) keeps the splash up under the dialog until the answer. WSL folders are still asked about by their remote window.

Closes #3648

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:26:51 +08:00
LU XIANGRUIтаwildcatDownstairs da3b00518f fix(editor): take a hidden tab's tooltips off the page with its view (#3662)
A slow Go to Implementation left its "Finding navigation target…" hint on the page after the target opened in another tab. Editor tooltips are parented to document.body, outside the view, so hiding a tab left any open tooltip (hint, hover, completion) behind, and the pending-hint cleanup skipped detached views.

Each tab now has its own tooltip layer that leaves and returns with its view, and hint cleanup and timeouts also run on hidden views.

Closes #3647

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:24:53 +08:00
l0ng-ai 87e4dcf42b feat(agents): toggle sending the current file and selection as IDE context (#3664)
A toolbar button in the agent composer turns IDE context on or off (on by default, remembered). While on, each message carries the focused editor's file, or its selected lines as a line-range mention, unless the draft already references that file.

Closes #3633
2026-11-16 12:22:56 +08:00
l0ng-ai c860649b13 test(app): mock invoke for the system notification in the update checks (#3661)
Balloons are mirrored to a system notification since #3606, which calls invoke; the update-check test's @tauri-apps/api/core mock had none, so 28 cases failed on main.
2026-11-16 12:13:33 +08:00
LU XIANGRUIтаwildcatDownstairs 07afe43d0d feat(settings): import keymaps, terminal font, tabs and indents and more editor options from JetBrains (#3650)
Import Settings from a JetBrains IDE now also brings over the keymaps (the IDE's active one becomes current), the terminal font, Tabs and Indents of the current code style scheme, console soft wrap and about 45 more EditorSettings / CodeInsightSettings options. The IDEA keymap parser moves to src/platform so the import can use it, and now accepts the lower-case key names IDEA writes in user keymaps (every non-letter shortcut of a user keymap was dropped before, also in Settings › Keymap › Import).

Closes #3649

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:12:21 +08:00
Muuтаmuutot 8ca2e089a3 fix(vcs): highlight diff viewers with the editor's syntax and semantic colours (#3653)
Diff viewers used a trimmed highlight style (14 tag groups), loaded languages straight from @codemirror/language-data (missing the editor's own modes, tag patches and the data-language attribute that language-scoped colour schemes key on), and had no semantic-token layer. They now use the editor's highlight style and language pipeline, and panes showing an open document get semantic highlighting.

Co-authored-by: muutot <[email protected]>
2026-11-16 12:10:24 +08:00
terwerтаterwer 41a8fbc591 fix(agents): read Codex session metadata from rollout payloads (#3659)
Current Codex rollouts start with a top-level session_meta record whose id and cwd live in payload; the scanner read them from the outer object and silently skipped every such session in the external-session import list. Read the payload, keeping the nested and unwrapped forms.

Closes #3655

Co-authored-by: terwer <[email protected]>
2026-11-16 12:07:54 +08:00
LU XIANGRUIтаwildcatDownstairs 3a0536eafc fix(menu): keep the menu usable while a Settings window is in front (#3657)
On macOS the backend treated the Settings window as modal and dropped every menu item except Quit, Settings, Project Structure and New Projects Settings, while still showing them enabled. Items chosen with Settings in front now run in its project window, which is brought forward; once what the action opened closes (or right away if it opened nothing) Settings comes back to the front. The project window pushes its menu enablement once on blur, so editor-only items grey out, and enablement pushed by other windows no longer overrides the front window's.

Closes #3625

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 12:07:09 +08:00
kevinh 9cbdde526b fix(vcs): update and roll back a project whose submodules changed (#3656)
git status lists submodules at another commit or with changes inside among the superproject's changes, but git stash leaves them in place, so the stash added no entry and Update Project (merge, rebase, checkout, reset) failed with "could not save the local changes". A stash that adds no entry now means there was nothing to put aside. Rollback of a submodule entry, or of a folder containing one, now runs git restore --recurse-submodules --worktree: the submodule goes back to the recorded commit with its tracked files restored; untracked files are kept.

Closes #3632

Co-authored-by: kevinh458 <[email protected]>
2026-11-16 12:02:43 +08:00
l0ng-ai 2878eb8d87 feat(sdk): add a JDK from disk in Project Structure › SDKs (#3660)
The SDKs list offered only Download JDK…. The toolbar's + now also has Add JDK from Disk…: the picked folder is checked to be a JDK home and kept in the global languages.java.addedJdks, which detection lists from then on, so it appears in every JDK picker. − removes a JDK added this way.

Closes #3628
2026-11-16 12:00:30 +08:00
l0ng-ai 2e764d74f8 fix(debugger): end a program suspended at a breakpoint at once on Stop (#3658)
For adapters without a terminate request (Delve, java-debug), Stop sent SIGTERM and waited up to 10 s. A program suspended in the debugger cannot act on SIGTERM (on macOS not even SIGKILL while debugserver holds it), so Stop sat in "stopping" for the full wait. When the session is suspended, Stop now kills the program's tree, sends disconnect with terminateDebuggee so the adapter ends it, and skips the wait for shutdown output. A running program still gets SIGTERM first.

Fixes #3623
2026-11-16 11:48:55 +08:00
59 змінених файлів з 1772 додано та 200 видалено

No files matched your search

+20 -5
Переглянути файл
@@ -134,7 +134,10 @@ fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
let payload =
line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
line.get("type")
.and_then(serde_json::Value::as_str)
.filter(|t| *t == "session_meta")
.map(|_| line.get("payload").unwrap_or(line))
})?;
let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
@@ -293,16 +296,28 @@ mod tests {
assert_eq!(sessions[0].title, "hello there");
}
#[test]
fn codex_meta_accepts_current_and_legacy_shapes() {
let meta = json!({"id": "thread-1", "cwd": "/work/app"});
for line in [
json!({"type": "session_meta", "payload": meta}),
json!({"payload": {"type": "session_meta", "payload": meta}}),
json!({"type": "session_meta", "id": "thread-1", "cwd": "/work/app"}),
] {
assert_eq!(codex_meta(&line), Some(("thread-1".to_owned(), Some("/work/app".to_owned()))));
}
}
#[test]
fn lists_codex_rollouts_with_meta() {
let tmp = tempfile::tempdir().unwrap();
write(
&tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
&[
json!({"timestamp": "t", "payload": {"type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
json!({"timestamp": "t", "payload": {"type": "user_message",
"payload": {"message": "add tests"}}}),
json!({"timestamp": "t", "type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}),
json!({"timestamp": "t", "type": "event_msg",
"payload": {"type": "user_message", "message": "add tests"}}),
],
);
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
+3
Переглянути файл
@@ -1347,6 +1347,9 @@ pub struct JavaSettings {
pub jdtls_vm_args: String,
/// Share one JDT LS across builds in an ordinary project window; other windows remain separate.
pub jdtls_shared: bool,
/// JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
/// detected ones.
pub added_jdks: Vec<String>,
/// Build Tools › Maven.
pub maven: MavenSettings,
/// Build Tools › Gradle.
+10 -3
Переглянути файл
@@ -1244,11 +1244,18 @@ impl DebugManager {
// rdbg's terminate exits the Ruby process without terminating its children.
let graceful =
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
// is told to end it. A killed program has no shutdown output to wait for.
let killed = own_terminate && !graceful && s.suspended.get();
if killed {
crate::session::signal_debuggee(s, true).await;
}
if !s.conn.is_closed() {
if graceful {
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
}
if !graceful && !own_terminate {
if !graceful && (!own_terminate || killed) {
let _ = s
.conn
.request_timeout(
@@ -1259,7 +1266,7 @@ impl DebugManager {
.await;
}
}
if own_terminate && !graceful {
if own_terminate && !graceful && !killed {
// Signal before anything else: waiting on a request the adapter may not answer
// would delay the shutdown the console is supposed to show.
crate::session::signal_debuggee(s, false).await;
@@ -1278,7 +1285,7 @@ impl DebugManager {
// lets Run start again into an occupied port, so wait for the program first — with the
// connection still open, so a second Stop can find the session and kill it.
crate::session::wait_for_debuggee(s, terminate).await;
if terminate && s.request == "launch" {
if terminate && s.request == "launch" && !killed {
// The adapter reports `terminated` only after it has drained the program's console
// (java-debug waits up to 5 s for the pump): closing before that drops the last
// shutdown lines from the console.
+46
Переглянути файл
@@ -527,6 +527,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"disconnect" => {
// Like Delve: the adapter ends the program it launched.
#[cfg(unix)]
if msg["arguments"]["terminateDebuggee"] == true
&& let Some(pid) = script.debuggee_pid
{
// SAFETY: plain syscall on the test's own child process.
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
}
ok!(msg, Value::Null);
let _ = w.lock().await.shutdown().await;
break;
@@ -2319,6 +2327,44 @@ async fn stop_waits_for_the_launched_program_to_exit() {
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
}
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
#[cfg(unix)]
#[tokio::test]
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
let mut child = std::process::Command::new("python3")
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
.spawn()
.unwrap();
let pid = child.id();
let exited = Arc::new(AtomicBool::new(false));
{
let exited = exited.clone();
std::thread::spawn(move || {
let _ = child.wait();
exited.store(true, Ordering::Release);
});
}
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let session = h.manager.session(id).unwrap();
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
let started = Instant::now();
h.manager.stop(id).await.unwrap();
let elapsed = started.elapsed();
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
let deadline = Instant::now() + Duration::from_secs(2);
while !exited.load(Ordering::Acquire) {
assert!(Instant::now() < deadline, "the suspended program was left running");
tokio::time::sleep(Duration::from_millis(10)).await;
}
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_stop_kills_the_program_instead_of_waiting() {
+9
Переглянути файл
@@ -190,6 +190,7 @@ impl Host {
open_locks: Default::default(),
};
host.apply_proxy();
host.apply_added_jdks();
ops::agent::move_user_mcp_values(&host);
host
}
@@ -564,3 +565,11 @@ mod tests {
host.close_project("main");
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
+3
Переглянути файл
@@ -232,6 +232,9 @@ pub fn set_settings(
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
host.apply_added_jdks();
}
if is_proxy {
host.apply_proxy();
}
+14
Переглянути файл
@@ -37,6 +37,9 @@ pub struct ProjectInterpreter {
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
}
let root = project.as_ref().map(|p| p.root.clone());
// The interpreter the project uses is a choice even where detection doesn't look (a
// virtualenv in a subfolder, one picked by path), so it shows by name and version.
@@ -372,9 +375,20 @@ pub async fn sdk_python_pip(
result?
}
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
/// `path` is no JDK home (Add JDK from Disk…).
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
.await
.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
d.add(
"sdk_python_project_interpreters",
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
+2
Переглянути файл
@@ -885,6 +885,8 @@ pub fn jdk_sdk(j: &crate::java::Jdk) -> Sdk {
"JAVA_HOME"
} else if crate::java::is_downloaded(&j.home) {
"downloaded"
} else if crate::java::is_added(&j.home) {
"added"
} else {
version_managers::manager_of(&j.home).unwrap_or("system")
};
+41
Переглянути файл
@@ -138,6 +138,26 @@ pub fn add_jdk_root(dir: &Path) {
}
}
/// JDK homes added by hand (Settings › SDKs › Add JDK from Disk…).
static ADDED: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
/// Sets the JDK homes added by hand; the next scan lists them (a change drops the cached scan).
pub fn set_added_jdks(homes: impl IntoIterator<Item = PathBuf>) {
let homes: Vec<PathBuf> = homes.into_iter().filter(|h| !h.as_os_str().is_empty()).collect();
let mut added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
if *added != homes {
*added = homes;
drop(added);
*JDKS.lock().unwrap_or_else(|e| e.into_inner()) = None;
}
}
/// Whether `home` is a JDK added by hand.
pub fn is_added(home: &Path) -> bool {
let added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
added.iter().any(|h| jdk_at(h).is_some_and(|j| j.home == home))
}
/// Whether `home` lies in a folder registered with [`add_jdk_root`].
pub fn is_downloaded(home: &Path) -> bool {
let roots = EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner());
@@ -190,6 +210,7 @@ fn scan() -> Vec<Jdk> {
for (dir, _) in ide_core::version_managers::installs(ide_core::version_managers::Tool::Java) {
homes.extend([dir.join("Contents/Home"), dir]);
}
homes.extend(ADDED.lock().unwrap_or_else(|e| e.into_inner()).iter().cloned());
let mut out: Vec<Jdk> = Vec::new();
for h in homes {
if let Some(jdk) = jdk_at(&h)
@@ -1364,6 +1385,26 @@ mod tests {
assert!(is_downloaded(&home) && !is_downloaded(Path::new("/elsewhere")));
}
#[test]
fn jdks_added_by_hand_are_listed_until_removed() {
let tmp = tempfile::tempdir().unwrap();
// A macOS bundle picked as its folder: listed by its `Contents/Home`.
let bundle = tmp.path().join("odd place/my-jdk.jdk");
let home = bundle.join("Contents/Home");
std::fs::create_dir_all(home.join("bin")).unwrap();
std::fs::write(home.join("release"), "JAVA_VERSION=\"17.0.9\"\nIMPLEMENTOR=\"Acme\"\n").unwrap();
std::fs::write(home.join("bin").join(crate::exe("java")), "").unwrap();
let home = dunce::canonicalize(&home).unwrap();
set_added_jdks([bundle.clone()]);
assert!(installed_jdks().iter().any(|j| j.home == home && j.major == 17));
assert!(is_added(&home));
let sdk = crate::jdk_sdk(&jdk_at(&bundle).unwrap());
assert_eq!((sdk.name.as_str(), sdk.source.as_str()), ("Acme 17.0.9", "added"));
set_added_jdks(Vec::new());
assert!(!installed_jdks().iter().any(|j| j.home == home));
assert!(!is_added(&home));
}
#[test]
fn jdtls_runs_on_the_chosen_server_jdk() {
let fixtures = tempfile::tempdir().unwrap();
+2 -1
Переглянути файл
@@ -1159,7 +1159,8 @@ impl Repo {
write::stage_patch(self, patch, &|path| encoding(path).map(Into::into))
}
/// Discards unstaged changes: tracked paths are restored from the index (staged
/// changes are kept), untracked files and directories are deleted.
/// changes are kept), untracked files and directories are deleted. A submodule goes back
/// to the commit the index records, with its tracked files restored.
pub fn discard(&self, paths: &[PathBuf]) -> IdeResult<()> {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::discard(self, paths)
+9 -6
Переглянути файл
@@ -25,16 +25,19 @@ pub(crate) fn save(r: &Repo, message: &str) -> IdeResult<()> {
if run(r.root(), &["status", "--porcelain", "--untracked-files=no"], None)?.stdout_str().trim().is_empty() {
return Ok(());
}
let before = run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).map(|o| o.stdout_str()).ok();
let before = stash_top(r);
run(r.root(), &["stash", "push", "-q", "-m", message], None)?;
let id = run(r.root(), &["rev-parse", "refs/stash"], None)?.stdout_str();
if before.as_deref().map(str::trim) == Some(id.trim()) {
return Err(IdeError::invalid("could not save the local changes"));
}
std::fs::write(marker, id.trim())?;
// A stash that succeeds without a new entry found nothing it saves: the status above also
// lists submodules at another commit or with changes inside, which a stash leaves in place.
let Some(id) = stash_top(r).filter(|id| Some(id) != before.as_ref()) else { return Ok(()) };
std::fs::write(marker, id)?;
Ok(())
}
fn stash_top(r: &Repo) -> Option<String> {
run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).ok().map(|o| o.stdout_str().trim().to_owned())
}
/// Brings the saved changes back once no operation is in progress. Fails when they come
/// back with conflicts (they then also stay in the stash).
pub(crate) fn restore(r: &Repo) -> IdeResult<()> {
+17 -6
Переглянути файл
@@ -391,18 +391,24 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
let rel = r.rel_paths(paths)?;
// `git restore --worktree` refuses unmerged paths: roll those back to HEAD first.
discard_unmerged(r, &rel)?;
let (mut tracked, mut untracked) = (Vec::new(), Vec::new());
let (mut tracked, mut untracked, mut submodules) = (Vec::new(), Vec::new(), Vec::new());
{
let repo = r.gix()?;
let index = repo.index_or_empty().map_err(gx)?;
for p in rel {
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).is_ok();
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).ok().map(|i| &index.entries()[i]);
let dir_prefix = if p == "." { String::new() } else { format!("{}/", p.trim_end_matches('/')) };
let has_tracked_children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes())).is_some();
if exact {
tracked.push(p);
let children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes()));
if let Some(entry) = exact {
if entry.mode.is_submodule() {
submodules.push(p);
} else {
tracked.push(p);
}
} else if r.abs_path(&p).is_dir() {
if has_tracked_children {
if let Some(children) = children {
submodules
.extend(children.iter().filter(|e| e.mode.is_submodule()).map(|e| e.path(&index).to_string()));
tracked.push(p.clone());
}
untracked.push(p);
@@ -412,6 +418,11 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
}
}
run_paths(r, &["restore", "--worktree"], &tracked)?;
// A plain restore leaves a submodule alone. This one checks out the commit the index
// records there and restores its tracked files, keeping its untracked ones.
if crate::execution_allowed() {
run_paths(r, &["restore", "--recurse-submodules", "--worktree"], &submodules)?;
}
if !untracked.is_empty() {
// `git clean` keeps ignored files and refuses paths outside the worktree.
run_paths(r, &["clean", "-f", "-d", "-q"], &untracked)?;
+69 -1
Переглянути файл
@@ -69,7 +69,8 @@ impl Fixture {
fn push_from_other(&self, bare: &Path, rel: &str, content: &str) {
let other = self.tmp.path().join(format!("other-{}", rel.replace('/', "_")));
if !other.exists() {
git_in(self.tmp.path(), &["clone", "-q", bare.to_str().unwrap(), other.to_str().unwrap()]);
let (bare, other_dir) = (bare.to_str().unwrap(), other.to_str().unwrap());
git_in(self.tmp.path(), &["clone", "-q", "-c", "core.autocrlf=false", bare, other_dir]);
configure(&other);
}
git_in(&other, &["pull", "-q", "--rebase"]);
@@ -636,6 +637,73 @@ fn update_with_rebase_keeps_a_file_added_then_deleted_added_to_the_index() {
assert!(fx.git(&["status", "--porcelain", "--", "ad.txt"]).starts_with('A'), "still added");
}
/// Submodules `dirty` and `moved` (each with commits "one" and "two", at "two") committed in
/// the clone of [`Fixture::with_origin`] and pushed; then `dirty` gets an uncommitted edit of a
/// tracked file plus an untracked file, and `moved` is checked out at "one". Returns the commit
/// the superproject records for `moved`.
fn with_changed_submodules(fx: &Fixture) -> String {
for name in ["dirty", "moved"] {
let lib = fx.tmp.path().join(format!("lib-{name}"));
std::fs::create_dir(&lib).unwrap();
git_in(&lib, &["init", "-q"]);
configure(&lib);
std::fs::write(lib.join("f.txt"), "one\n").unwrap();
git_in(&lib, &["add", "-A"]);
git_in(&lib, &["commit", "-q", "-m", "one"]);
std::fs::write(lib.join("f.txt"), "two\n").unwrap();
git_in(&lib, &["commit", "-q", "-am", "two"]);
let url = lib.to_str().unwrap();
fx.git(&["-c", "protocol.file.allow=always", "-c", "core.autocrlf=false", "submodule", "add", "-q", url, name]);
configure(&fx.path(name));
}
fx.commit_all("submodules");
fx.git(&["push", "-q", "origin", "main"]);
let recorded = git_in(&fx.path("moved"), &["rev-parse", "HEAD"]);
fx.write("dirty/f.txt", "edited\n");
fx.write("dirty/untracked.txt", "u\n");
git_in(&fx.path("moved"), &["checkout", "-q", "HEAD~1"]);
recorded
}
/// git lists submodules at another commit or with changes inside among the superproject's
/// changes, but its stash leaves them in place, so Update Project has nothing to put aside (#3632).
#[test]
fn update_with_changed_submodules_and_no_other_local_changes() {
for (rebase, earlier_stash) in [(false, false), (false, true), (true, false), (true, true)] {
let (fx, bare) = Fixture::with_origin();
let recorded = with_changed_submodules(&fx);
if earlier_stash {
fx.write("a.txt", "stashed\n");
fx.git(&["stash", "push", "-q", "-m", "earlier"]);
}
fx.push_from_other(&bare, "remote.txt", "r\n");
let repo = fx.repo();
let (cancel, out) = quiet();
repo.pull(rebase, &cancel, &out).unwrap_or_else(|e| panic!("rebase={rebase} stash={earlier_stash}: {e}"));
assert!(fx.exists("remote.txt"));
assert_eq!(fx.read("dirty/f.txt"), "edited\n");
assert_ne!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
let stashes = fx.git(&["stash", "list"]);
assert_eq!(stashes.lines().count(), usize::from(earlier_stash), "{stashes}");
assert!(!fx.dir.join(".git/openidea-saved-changes").exists());
}
}
#[test]
fn rollback_changed_submodules_restores_the_recorded_commit_and_tracked_files() {
for whole_root in [false, true] {
let (fx, _bare) = Fixture::with_origin();
let recorded = with_changed_submodules(&fx);
let repo = fx.repo();
let paths = if whole_root { vec![fx.dir.clone()] } else { vec![fx.path("dirty"), fx.path("moved")] };
repo.discard(&paths).unwrap();
assert_eq!(fx.read("dirty/f.txt"), "two\n", "whole_root={whole_root}");
assert_eq!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
assert_eq!(fx.read("dirty/untracked.txt"), "u\n", "untracked files of a submodule are kept");
assert_eq!(fx.git(&["status", "--porcelain", "--ignore-submodules=untracked"]), "");
}
}
#[test]
fn reset_to_the_remote_branch_drops_local_commits_and_keeps_local_changes() {
let (fx, bare) = Fixture::with_origin();
+60 -8
Переглянути файл
@@ -441,13 +441,26 @@ impl SettingsStore {
#[serde(rename_all = "camelCase")]
pub struct JetBrainsSettings {
pub entries: Vec<String>,
/// Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads.
/// Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
/// `codestyles/*.xml` and some of `options/`.
pub files: BTreeMap<String, String>,
}
const JETBRAINS_MARKER: &str = "IntelliJ IDEA Global Settings";
const JETBRAINS_OPTIONS: [&str; 4] =
["options/editor-font.xml", "options/colors.scheme.xml", "options/editor.xml", "options/ide.general.xml"];
const JETBRAINS_OPTIONS: [&str; 9] = [
"options/editor-font.xml",
"options/terminal-font.xml",
"options/colors.scheme.xml",
"options/code.style.schemes.xml",
"options/editor.xml",
"options/ide.general.xml",
// The active keymap is stored per operating system.
"options/mac/keymap.xml",
"options/windows/keymap.xml",
"options/linux/keymap.xml",
];
/// Folders whose files are all read: (folder, extension).
const JETBRAINS_READ_DIRS: [(&str, &str); 3] = [("colors/", ".icls"), ("keymaps/", ".xml"), ("codestyles/", ".xml")];
const JETBRAINS_MAX_TEXT: u64 = 4 << 20;
/// The settings of a JetBrains IDE: an exported `settings.zip`, or the IDE's own settings folder
@@ -458,11 +471,23 @@ pub fn read_jetbrains_settings(path: &Path) -> IdeResult<JetBrainsSettings> {
fn is_mapped_jetbrains_file(name: &str) -> bool {
JETBRAINS_OPTIONS.contains(&name)
|| name.strip_prefix("colors/").is_some_and(|n| !n.contains('/') && n.ends_with(".icls"))
|| JETBRAINS_READ_DIRS
.iter()
.any(|(dir, ext)| name.strip_prefix(dir).is_some_and(|n| !n.contains('/') && n.ends_with(ext)))
}
/// Folders of the settings folder whose files are listed (their names say what the user customised).
const JETBRAINS_LISTED_DIRS: [&str; 6] = ["options", "colors", "keymaps", "codestyles", "templates", "inspection"];
const JETBRAINS_LISTED_DIRS: [&str; 9] = [
"options",
"options/mac",
"options/windows",
"options/linux",
"colors",
"keymaps",
"codestyles",
"templates",
"inspection",
];
fn read_jetbrains_folder(dir: &Path) -> IdeResult<JetBrainsSettings> {
use std::io::Read;
@@ -936,11 +961,25 @@ mod tests {
("options/editor-font.xml", "<application/>"),
("options/vcs.xml", "<application/>"),
("keymaps/macOS.xml", "<keymap/>"),
("keymaps/nested/ignored.xml", "<keymap/>"),
("codestyles/Default.xml", "<code_scheme/>"),
("options/mac/keymap.xml", "<application/>"),
("options/terminal-font.xml", "<application/>"),
],
);
let read = read_jetbrains_settings(&ok).unwrap();
assert_eq!(read.entries.len(), 5);
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
assert_eq!(read.entries.len(), 9);
assert_eq!(
read.files.keys().collect::<Vec<_>>(),
[
"codestyles/Default.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"options/editor-font.xml",
"options/mac/keymap.xml",
"options/terminal-font.xml"
]
);
assert!(read_jetbrains_settings(&write("other.zip", &[("options/editor.xml", "")])).is_err());
std::fs::write(tmp.path().join("plain.zip"), "not a zip").unwrap();
assert!(read_jetbrains_settings(&tmp.path().join("plain.zip")).is_err());
@@ -959,18 +998,31 @@ mod tests {
put("colors/nested/ignored.icls", "<scheme/>");
put("options/editor-font.xml", "<application/>");
put("options/vcs.xml", "<application/>");
put("options/mac/keymap.xml", "<application/>");
put("keymaps/macOS.xml", "<keymap/>");
put("codestyles/Default.xml", "<code_scheme/>");
put("plugins/Tools/lib/tools.jar", "jar");
let read = read_jetbrains_settings(&config).unwrap();
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
assert_eq!(
read.files.keys().collect::<Vec<_>>(),
[
"codestyles/Default.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"options/editor-font.xml",
"options/mac/keymap.xml"
]
);
assert_eq!(
read.entries,
[
"options/editor-font.xml",
"options/vcs.xml",
"options/mac/keymap.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"codestyles/Default.xml",
"installed.txt"
]
);
+4
Переглянути файл
@@ -36,6 +36,10 @@ body,
opacity: 0;
pointer-events: none;
}
/* A question asked while the window opens (Trust Project?) shows over the splash (platform/splash.ts). */
.splash.splash-under-dialogs {
z-index: calc(var(--z-dialog, 900) - 1);
}
:root[data-theme^="dark"] .splash {
color: var(--fg-muted, var(--boot-fg, #8c8f95));
}
+1
Переглянути файл
@@ -489,6 +489,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
sdk::sdk_python_interpreter,
sdk::sdk_python_effective,
sdk::sdk_php_effective,
sdk::sdk_jdk_at,
sdk::sdk_container_python,
sdk::sdk_container_python_refresh,
sdk::sdk_php_xdebug,
+7
Переглянути файл
@@ -17,6 +17,13 @@ pub async fn sdk_detect(window: Window, state: State<'_, AppState>, kind: SdkKin
ide_host::ops::sdk::sdk_detect(&state.host, window.label(), kind).await
}
/// The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home.
#[tauri::command]
#[specta::specta]
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
ide_host::ops::sdk::sdk_jdk_at(path).await
}
/// The Python interpreters of the recently opened projects, each with its project.
#[tauri::command]
#[specta::specta]
+7 -1
Переглянути файл
@@ -330,7 +330,13 @@ pub fn menu_model(app: AppHandle, state: State<'_, AppState>, menu_state: State<
/// disabled in place (no rebuild).
#[tauri::command]
#[specta::specta]
pub fn menu_set_disabled(app: AppHandle, menu_state: State<'_, MenuState>, ids: Vec<String>) {
pub fn menu_set_disabled(window: WebviewWindow, app: AppHandle, menu_state: State<'_, MenuState>, ids: Vec<String>) {
// The window whose menu runs: a project window also while its Settings window is focused.
if menu::native_menu_bar()
&& windows::target_window(&app).is_some_and(|target| !owns_menu_config(window.label(), target.label()))
{
return;
}
let disabled: std::collections::HashSet<String> = ids.into_iter().collect();
if *menu_state.disabled.lock() == disabled {
return;
+13 -14
Переглянути файл
@@ -373,25 +373,24 @@ pub(crate) fn dispatch_menu_action(app: &tauri::AppHandle, id: &str) {
let Some(route) = menu::route(&menu::spec(menu::Os::current()), id) else { return };
match windows::target_window(app) {
Some(w) => {
// App-level items of an auxiliary window go to its project window. Settings is modal for it:
// nothing else gets through. Others handle their own items; Close Tab closes the window.
let label = match windows::auxiliary(w.label()) {
Some((_, parent))
if matches!(
route.action.as_str(),
"app.quit" | "file.settings" | "file.projectStructure" | "file.newProjectsSettings"
) =>
{
parent
// The window to bring back to the front once what the action shows is closed (Settings).
let mut return_to = None;
let label = match windows::menu_destination(w.label(), &route.action) {
windows::MenuDestination::Own => w.label(),
windows::MenuDestination::Parent { label, raise } => {
if raise && let Some(parent) = app.get_webview_window(label) {
windows::focus(&parent);
return_to = Some(w.label());
}
label
}
Some((kind, _)) if kind.modal() => return,
Some(_) if route.action == "editor.closeTab" => {
windows::MenuDestination::Close => {
let _ = w.close();
return;
}
_ => w.label(),
};
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &route) {
let event = menu::MenuEvent { route: &route, return_to };
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &event) {
tracing::warn!("failed to deliver menu event {id}: {e}");
}
}
+11
Переглянути файл
@@ -904,6 +904,17 @@ pub struct MenuRoute {
pub arg: Option<String>,
}
/// Payload of [`MENU_EVENT`]: the route, and the window that was in front when the item was
/// chosen if the action runs in another one (a Settings window's project window).
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MenuEvent<'a> {
#[serde(flatten)]
pub route: &'a MenuRoute,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_to: Option<&'a str>,
}
/// Maps a clicked item id to the action to run. `None` for ids that are not
/// IDE items (native roles, placeholders).
pub fn route(spec: &[Entry], id: &str) -> Option<MenuRoute> {
+51 -2
Переглянути файл
@@ -360,8 +360,8 @@ impl AuxKind {
self != AuxKind::Settings
}
/// Modal for its parent: menu items other than app-level ones are dropped.
pub fn modal(self) -> bool {
/// Has no actions of its own: menu items run in its project window.
fn runs_menu_in_parent(self) -> bool {
self == AuxKind::Settings
}
@@ -386,6 +386,34 @@ pub fn auxiliary(label: &str) -> Option<(AuxKind, &str)> {
})
}
/// Where a menu item chosen while window `label` is focused runs.
#[derive(Debug, PartialEq, Eq)]
pub enum MenuDestination<'a> {
/// The window's own frontend.
Own,
/// The project window `label`; `raise` brings it to the front so what the action shows is seen.
Parent { label: &'a str, raise: bool },
/// The window itself is the tab: Close Tab closes it.
Close,
}
/// Actions an auxiliary window always leaves to its project window.
const PARENT_ACTIONS: [&str; 4] = ["app.quit", "file.settings", "file.projectStructure", "file.newProjectsSettings"];
/// Where menu item `action` runs while window `label` is focused. As in IDEA, the menu stays usable
/// with Settings open: it runs in the project window, whose enablement (no focused editor) the menu shows.
pub fn menu_destination<'a>(label: &'a str, action: &str) -> MenuDestination<'a> {
match auxiliary(label) {
None => MenuDestination::Own,
Some((_, parent)) if PARENT_ACTIONS.contains(&action) => {
MenuDestination::Parent { label: parent, raise: false }
}
Some((kind, parent)) if kind.runs_menu_in_parent() => MenuDestination::Parent { label: parent, raise: true },
Some(_) if action == "editor.closeTab" => MenuDestination::Close,
Some(_) => MenuDestination::Own,
}
}
/// The project window an auxiliary window belongs to (`settings-main` → `main`).
pub fn auxiliary_parent(label: &str) -> Option<&str> {
auxiliary(label).map(|(_, parent)| parent)
@@ -2349,6 +2377,27 @@ mod tests {
assert_eq!(sorted_labels(labels.into_iter().filter(|l| auxiliary_parent(l).is_none())), ["main", "project-2"]);
}
#[test]
fn menu_items_chosen_in_settings_run_in_its_project_window() {
use MenuDestination::*;
for (label, action, expected) in [
("main", "app.about", Own),
("main", "editor.closeTab", Own),
// #3625: Settings has no actions of its own; the rest of the menu runs in the project window.
("settings-main", "app.checkForUpdates", Parent { label: "main", raise: true }),
("settings-project-2", "file.newFile", Parent { label: "project-2", raise: true }),
("settings-main", "editor.closeTab", Parent { label: "main", raise: true }),
("settings-main", "file.settings", Parent { label: "main", raise: false }),
("settings-main", "app.quit", Parent { label: "main", raise: false }),
("comparison-main-0", "app.quit", Parent { label: "main", raise: false }),
("comparison-main-0", "editor.closeTab", Close),
("diff-main-1", "vcs.diff.next", Own),
("deployment-main", "app.about", Own),
] {
assert_eq!(menu_destination(label, action), expected, "{label} {action}");
}
}
#[test]
fn settings_bounds_fit_current_work_area() {
for (parent, size, work, expected) in [
+1
Переглянути файл
@@ -513,6 +513,7 @@ scaffold_requirements always project_host bin
sdk_container_python trusted project_host bindings sync
sdk_container_python_refresh trusted project_host bindings async
sdk_detect trusted project_host bindings async
sdk_jdk_at trusted project_host bindings async
sdk_locate_tools trusted project_host bindings async
sdk_php_composer_install trusted project_host bindings async
sdk_php_effective trusted project_host bindings sync
+29 -1
Переглянути файл
@@ -1096,6 +1096,26 @@ export const commands = {
sdkPythonEffective: (near: string | null) => typedError<string | null, IdeError>(__TAURI_INVOKE("sdk_python_effective", { near })),
/** The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`. */
sdkPhpEffective: () => typedError<string | null, IdeError>(__TAURI_INVOKE("sdk_php_effective")),
/** The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home. */
sdkJdkAt: (path: string) => typedError<{
/**
* Executable (`python`, `node`, `pnpm`) or directory (Rust toolchain bin
* dir, GOROOT, TypeScript `lib` dir) that the setting stores.
*/
path: IpcPath,
/** Display name, e.g. `Python 3.12 (.venv)` or `stable-aarch64-apple-darwin`. */
name: string,
version: string | null,
/**
* Where it was found: `venv` | `system` | `pyenv` | `conda` | `uv` | `nvm` |
* `rustup` | `bundled` | `workspace` | `path` …
*/
source: string,
/** Environment / toolchain root (virtualenv dir, rustup toolchain dir, GOROOT). */
home: IpcPath | null,
/** Rust standard library sources, Go default GOPATH. */
extra: IpcPath | null,
} | null, IdeError>(__TAURI_INVOKE("sdk_jdk_at", { path })),
/** The project interpreter when it is a Docker or Compose run target's, with its snapshot. */
sdkContainerPython: () => typedError<{
/** The run target's id. */
@@ -6720,6 +6740,11 @@ export type JavaSettings = {
jdtlsVmArgs?: string,
/** Share one JDT LS across builds in an ordinary project window; other windows remain separate. */
jdtlsShared?: boolean,
/**
* JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
* detected ones.
*/
addedJdks?: string[],
/** Build Tools › Maven. */
maven?: MavenSettings,
/** Build Tools › Gradle. */
@@ -6748,7 +6773,10 @@ export type JdkVendor = {
*/
export type JetBrainsSettings = {
entries: string[],
/** Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads. */
/**
* Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
* `codestyles/*.xml` and some of `options/`.
*/
files: { [key in string]: string },
};
+2 -1
Переглянути файл
@@ -134,7 +134,8 @@ class LensWidget extends WidgetType {
const guides = this.inline
? null
: guideVars(Math.floor(this.indent / this.indentUnit), this.indentUnit, this.rainbow);
if (!this.inline) dom.style.paddingLeft = `${Math.round(this.indent * view.defaultCharacterWidth) + LINE_INSET}px`;
if (!this.inline)
dom.style.paddingLeft = `calc(${LINE_INSET}px + ${this.indent} * var(--openidea-space, ${view.defaultCharacterWidth}px))`;
if (guides) {
dom.style.setProperty("--openidea-guide-images", guides.images);
dom.style.setProperty("--openidea-guide-positions", guides.positions);
+38 -10
Переглянути файл
@@ -1,4 +1,4 @@
import { afterEach, describe, expect, it } from "vitest";
import { afterEach, describe, expect, it, vi } from "vitest";
import { Compartment, EditorState, type Extension } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { indentUnit } from "@codemirror/language";
@@ -46,23 +46,25 @@ describe("indent guides", () => {
expect(guideVars(1, 4)).toBeNull();
expect(guideVars(3, 4)).toEqual({
images: "var(--openidea-guide), var(--openidea-guide)",
positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
positions: "calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
});
});
it("positions each guide the same way on lines of different depth", () => {
const v = mount(SOURCE);
expect(line(v, 1).classList.contains("cm-openidea-guides")).toBe(false);
expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0");
expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0",
);
expect(line(v, 3).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
});
it("keeps guides through blank lines inside a block", () => {
const v = mount(SOURCE);
expect(line(v, 4).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
});
@@ -77,7 +79,9 @@ describe("indent guides", () => {
]);
const [implLens, fnLens] = [...v.contentDOM.querySelectorAll<HTMLElement>(".cm-openidea-lens")];
expect(v.contentDOM.classList.contains("cm-openidea-guidesOn")).toBe(true);
expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0");
expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0",
);
expect(implLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("");
});
});
@@ -136,7 +140,7 @@ describe("rainbow indent guides", () => {
expect(guideVars(1, 4, true)).toBeNull();
expect(guideVars(3, 4, true)).toEqual({
images: "var(--openidea-guide-1), var(--openidea-guide-2)",
positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
positions: "calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
});
const deep = guideVars(8, 2, true)!;
expect(deep.images.split(", ")).toEqual([1, 2, 3, 4, 5, 1, 2].map((n) => `var(--openidea-guide-${n})`));
@@ -156,7 +160,9 @@ describe("rainbow indent guides", () => {
expect(images(line(v, 2))).toBe("var(--openidea-guide-1)");
expect(images(line(v, 3))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(images(line(v, 4))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(positions(line(v, 4))).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0");
expect(positions(line(v, 4))).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
expect(images(line(v, 6))).toBe("var(--openidea-guide-1)");
});
@@ -170,7 +176,27 @@ describe("rainbow indent guides", () => {
spaces.destroy();
const tabs = mount(body("\t"), [EditorState.tabSize.of(4)], rainbowIndentGuides, "\t");
expect(images(deepest(tabs))).toBe(expected);
expect(positions(deepest(tabs)).split(", ")[1]).toBe("calc(0.5px + 8ch) 0");
expect(positions(deepest(tabs)).split(/, (?=calc)/)[1]).toBe("calc(0.5px + 8 * var(--openidea-space, 1ch)) 0");
});
it("measures a column as the font's space width, so a proportional font keeps guides in the indentation", () => {
const rect = vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(function (
this: HTMLElement,
) {
const sample = this.textContent ?? "";
const width = /^ +$/.test(sample) ? sample.length * 3.5 : 0;
return { width, height: 0, top: 0, left: 0, right: width, bottom: 0, x: 0, y: 0, toJSON: () => ({}) };
});
try {
const v = mount(SOURCE);
(v as unknown as { measure(): void }).measure();
expect(v.scrollDOM.style.getPropertyValue("--openidea-space")).toBe("3.5px");
v.destroy();
expect(v.scrollDOM.style.getPropertyValue("--openidea-space")).toBe("");
view = undefined;
} finally {
rect.mockRestore();
}
});
it("does not count a partial indent unit as a level", () => {
@@ -211,7 +237,9 @@ describe("rainbow indent guides", () => {
});
const lens = () => view!.contentDOM.querySelector<HTMLElement>(".cm-openidea-lens")!;
expect(images(lens())).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(positions(lens())).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0");
expect(positions(lens())).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
view.dispatch({ effects: guides.reconfigure(indentGuides) });
expect(images(lens())).toBe("var(--openidea-guide), var(--openidea-guide)");
});
+33 -3
Переглянути файл
@@ -7,7 +7,9 @@
* the smaller level of their neighbours and code lens rows the level of the
* line they annotate (`guideVars`), so guides stay continuous. With rainbow
* guides each depth gets its own image, coloured from `--syn-rainbow-*`. The
* guide the caret is on takes the selected colour (`caretGuide`).
* guide the caret is on takes the selected colour (`caretGuide`). A column is
* the editor font's space width (`--openidea-space`, measured), not `ch`: in a
* proportional font a space is narrower than "0", and guides would drift into the code.
*/
import { countColumn, Facet, RangeSetBuilder, type EditorState, type Extension } from "@codemirror/state";
import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view";
@@ -17,6 +19,11 @@ import { LINE_INSET } from "./lineInset";
/** How far (px) a guide sits left of its column, so a caret in that column is right of it (IDEA's indent guide shift). */
const GUIDE_SHIFT = 2;
/** One column of indentation: a space in the editor font, as measured by the guides plugin. */
const SPACE = "var(--openidea-space, 1ch)";
const SPACE_SAMPLE = 64;
/** Number of `--openidea-guide-<n>` rainbow colours; deeper guides repeat them. */
export const GUIDE_COLORS = 5;
@@ -50,7 +57,7 @@ export function guideVars(
? `var(--openidea-guide-${((level - 1) % GUIDE_COLORS) + 1})`
: "var(--openidea-guide)",
);
positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step}ch) 0`);
positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step} * ${SPACE}) 0`);
}
return { images: images.join(", "), positions: positions.join(", ") };
}
@@ -187,10 +194,33 @@ export const indentGuides: Extension = [
ViewPlugin.fromClass(
class {
decorations: DecorationSet;
constructor(view: EditorView) {
private probe: HTMLElement;
constructor(readonly view: EditorView) {
// Inherits the editor font from the scroller, outside the content CodeMirror observes;
// the measured width goes on the scroller, where lines and code lens rows pick it up.
this.probe = document.createElement("span");
this.probe.setAttribute("aria-hidden", "true");
this.probe.style.cssText = "position: absolute; top: 0; left: 0; visibility: hidden; white-space: pre";
this.probe.textContent = " ".repeat(SPACE_SAMPLE);
view.scrollDOM.appendChild(this.probe);
this.decorations = build(view);
this.measure();
}
measure() {
this.view.requestMeasure({
key: this,
read: (view) => this.probe.getBoundingClientRect().width / (view.scaleX || 1) / SPACE_SAMPLE,
write: (width, view) => {
if (width > 0) view.scrollDOM.style.setProperty("--openidea-space", `${+width.toFixed(3)}px`);
},
});
}
destroy() {
this.probe.remove();
this.view.scrollDOM.style.removeProperty("--openidea-space");
}
update(u: ViewUpdate) {
if (u.geometryChanged) this.measure();
if (
u.docChanged ||
u.selectionSet ||
+34 -1
Переглянути файл
@@ -1,5 +1,6 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorState, StateEffect } from "@codemirror/state";
import { showTooltip, type Tooltip } from "@codemirror/view";
import { indentUnit, language as languageFacet } from "@codemirror/language";
import { HEAVY_LIMIT, onEditorEvent, registerSaveParticipant, remoteChange, shownAgain } from "@/editor/api";
import { createMemoryBackend, type MemoryBackend } from "../backend";
@@ -16,6 +17,15 @@ const host: SlotHost = {
onContextMenu: () => {},
};
const testTooltip: Tooltip = {
pos: 0,
create: () => {
const dom = document.createElement("div");
dom.className = "test-tab-tooltip";
return { dom };
},
};
async function settle() {
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
}
@@ -362,6 +372,29 @@ describe("DocumentManager + slots", () => {
manager.stop();
});
it("takes a hidden tab's tooltips off the page with its view, and back when it shows again (#3647)", async () => {
const { manager } = setup({ "/p/a.txt": "abc" });
const model = await manager.acquire("/p/a.txt");
const slot = new EditorSlot(model, "t1", host);
const other = new EditorSlot(model, "t2", host);
const tooltip = () => document.querySelector(".cm-tooltip.test-tab-tooltip");
const view = slot.mount(document.body);
// Any tooltip of the tab (a hint, hover, completion…): they live in `document.body`, outside the view.
view.dispatch({ effects: StateEffect.appendConfig.of(showTooltip.of(testTooltip)) });
expect(tooltip()).not.toBeNull();
slot.unmount();
other.mount(document.body);
expect(tooltip()).toBeNull();
other.unmount();
expect(slot.mount(document.body)).toBe(view);
expect(tooltip()).not.toBeNull();
// Disposing the tab leaves nothing of it in the page.
slot.dispose();
other.dispose();
expect(tooltip()).toBeNull();
manager.stop();
});
it("destroys the least recently hidden views beyond the kept ones, and kept views on dispose", async () => {
const { manager } = setup({ "/p/a.txt": "abc" });
const model = await manager.acquire("/p/a.txt");
+11 -1
Переглянути файл
@@ -20,7 +20,7 @@ import {
type TransactionSpec,
} from "@codemirror/state";
import { historyField } from "@codemirror/commands";
import { EditorView, ViewPlugin, keymap, type ViewUpdate } from "@codemirror/view";
import { EditorView, ViewPlugin, keymap, tooltips, type ViewUpdate } from "@codemirror/view";
import {
_addEditor,
_removeEditor,
@@ -69,6 +69,11 @@ export class EditorSlot {
view: EditorView | null = null;
/** The view kept, detached from the document, while the tab is hidden. */
private kept: EditorView | null = null;
/**
* The tab's tooltips (hints, hover, completion…). They live outside the view, in `document.body`,
* so they leave the page with the view when the tab is hidden instead of floating over the next tab.
*/
private readonly tooltipLayer = typeof document === "undefined" ? null : document.createElement("div");
/** The view's scroll offset, tracked so hiding it needn't read layout. */
private scrollPos = { top: 0, left: 0 };
handle: TextEditorHandle | null = null;
@@ -166,6 +171,8 @@ export class EditorSlot {
}
}),
Prec.highest(keymap.of([{ key: "Escape", run: () => this.host.onEscape?.(this) ?? false }])),
// Ahead of the shared `document.body` parent (the tooltip space still comes from it).
this.tooltipLayer ? Prec.highest(tooltips({ parent: this.tooltipLayer })) : [],
EditorView.domEventObservers({
scroll: (_e, view) => {
if (view === this.view) this.scrollPos = { top: view.scrollDOM.scrollTop, left: view.scrollDOM.scrollLeft };
@@ -200,6 +207,7 @@ export class EditorSlot {
mount(parent: HTMLElement): EditorView {
if (this.view) return this.view;
if (this.tooltipLayer && !this.tooltipLayer.isConnected) document.body.appendChild(this.tooltipLayer);
const kept = this.kept;
let view: EditorView;
if (kept) {
@@ -243,6 +251,7 @@ export class EditorSlot {
this.kept = view;
if (!keep) return this.release();
view.dom.remove();
this.tooltipLayer?.remove();
keptSlots.push(this);
if (keptSlots.length > KEPT_VIEWS) keptSlots.shift()!.release();
}
@@ -258,6 +267,7 @@ export class EditorSlot {
this.scroll = scrollSnapshotAt(view, this.scrollPos);
this.stored = view.state;
view.destroy();
this.tooltipLayer?.remove();
}
dispose() {
+4 -4
Переглянути файл
@@ -74,9 +74,8 @@ export function showHint(
clearTimeout(timers.get(view));
timers.set(
view,
setTimeout(() => {
if (view.dom.isConnected && view.state.field(hintField, false)) view.dispatch({ effects: setHint.of(null) });
}, opts.timeout ?? 4000),
// Also while the view is hidden: it would show the hint again when its tab is shown.
setTimeout(() => hideHint(view), opts.timeout ?? 4000),
);
}
@@ -104,9 +103,10 @@ export function showPendingHint(view: EditorView, content: string): () => void {
}, PENDING_HINT_DELAY_MS);
return () => {
clearTimeout(timer);
// Also when the request ended by opening another tab, which hid this view.
if (shown && view.state.field(hintField, false) === shown) {
clearTimeout(timers.get(view));
if (view.dom.isConnected) hideHint(view);
hideHint(view);
}
};
}
+5 -3
Переглянути файл
@@ -89,11 +89,13 @@ export function cellLspExtensions(ctx: EditorDocContext): Extension[] {
}
/**
* A diff pane showing a file's open document: hover / quick docs and ⌘/Ctrl-click navigation,
* so references can be followed while reviewing. Editing features stay with text editors.
* A diff pane showing a file's open document: hover / quick docs, ⌘/Ctrl-click
* navigation and semantic highlighting, so colours match the editor while
* reviewing. Editing features stay with text editors; panes without a document
* (revisions) get nothing from the semantic extension (`docOf` is null).
*/
export function diffLspExtensions(ctx: EditorDocContext): Extension[] {
return [lspDoc.of(ctx), lspTheme, hintExtension(), hoverExtension(), navigationExtension()];
return [lspDoc.of(ctx), lspTheme, hintExtension(), hoverExtension(), navigationExtension(), semanticExtension()];
}
export function activate(): () => void {
+21
Переглянути файл
@@ -70,6 +70,27 @@ describe("slow navigation feedback", () => {
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
});
it("clears the progress hint when the target opens in another tab and hides this view (#3647)", async () => {
let resolve!: (result: Awaited<ReturnType<typeof commands.lspGotoImplementation>>) => void;
lspGotoImplementation.mockImplementationOnce(() => new Promise((r) => (resolve = r)));
// Opening the target's tab detaches this tab's view, as `EditorSlot.unmount` does.
openFile.mockImplementationOnce(async () => view.dom.remove());
const pending = gotoTargets(view, "implementation");
await vi.advanceTimersByTimeAsync(250);
expect(document.querySelector(".cm-lsp-hint")?.textContent).toBe("Finding navigation target…");
resolve({
status: "ok",
data: [{ path: "/p/Impl.java", range: { start: { line: 1, col: 0 }, end: { line: 1, col: 4 } }, uri: null }],
});
await pending;
expect(openFile).toHaveBeenCalled();
expect(view.dom.isConnected).toBe(false);
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
// Shown again, the tab has no stale progress hint.
document.body.appendChild(view.dom);
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
});
it("shows progress while the chooser's rows load after a quick answer, until the chooser opens", async () => {
let finish!: (files: Map<string, string[]>) => void;
vi.spyOn(files, "readManyFileLines").mockImplementationOnce(() => new Promise((r) => (finish = r)));
+41 -2
Переглянути файл
@@ -66,7 +66,7 @@ import {
} from "./composerModel";
import { referenceExtensions, setReferences } from "./composerEditor";
import { referenceHover } from "./ReferenceChip";
import { composerDraft, updateComposer, useAgents } from "./store";
import { composerDraft, provideIdeContext, setIdeContext, updateComposer, useAgents } from "./store";
import { ImagePreview, imageSrc } from "./ImagePreview";
import { useAgentSettings } from "./agentSettings";
import styles from "./Composer.module.css";
@@ -933,6 +933,27 @@ export function Composer(props: ComposerProps) {
return { path: activePath, rel };
}, [activePath, projectRoot, root, text]);
const ideContext = useAgents((s) => s.ideContext);
useEffect(
() =>
provideIdeContext(id, () => {
const active = useEditorRegistry.getState().active;
const path = active?.ctx.path;
if (!active || !path || isVirtualUri(path)) return null;
const rel = relativeTo([projectRoot, root], path);
if (!rel || rel === ".") return null;
const { doc, selection } = active.view.state;
const { from, to } = selection.main;
if (from === to) return { path, rel };
const first = doc.lineAt(from).number;
const end = doc.lineAt(to);
// A selection ending at the start of a line does not take that line.
const last = end.from === to && end.number > first ? end.number - 1 : end.number;
return { path, rel, lines: { from: first, to: last } };
}),
[id, projectRoot, root],
);
const showContext = images.length > 0 || attached.length > 0 || !!suggested;
return (
@@ -1056,7 +1077,14 @@ export function Composer(props: ComposerProps) {
)}
{showContext && (
<div className={styles.context} onMouseDown={(e) => e.stopPropagation()}>
{suggested && (
{suggested && ideContext && (
<span className={styles.attachment} title={tx`${suggested.rel} is added to your request`}>
<Icon name={fileIconName(basename(suggested.rel), suggested.rel)} size={14} />
<span className={styles.attachmentName}>{basename(suggested.rel)}</span>
<span className={styles.suggestionHint}>{tx("Current File")}</span>
</span>
)}
{suggested && !ideContext && (
<button
type="button"
className={styles.suggestion}
@@ -1127,6 +1155,17 @@ export function Composer(props: ComposerProps) {
replace(from, to, before && !/\s/.test(before) ? " @" : "@");
}}
/>
<IconButton
icon="file-code"
title={
ideContext
? "IDE Context Enabled: the current file and selection are added to your request"
: "IDE Context Disabled: the current file and selection are not added to your request"
}
pressed={ideContext}
className={styles.composerButton}
onClick={() => setIdeContext(!ideContext)}
/>
<IconButton
icon="image"
title="Attach Image…"
+45 -1
Переглянути файл
@@ -14,6 +14,7 @@ const pathCompletions = vi.fn();
const fsProbe = vi.fn();
const fsEntryKind = vi.fn();
const findSymbols = vi.fn();
const agentPrompt = vi.fn((..._args: unknown[]) => Promise.resolve({ status: "ok", data: null }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
@@ -28,6 +29,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
fsProbe: (path: string) => fsProbe(path),
fsEntryKind: (path: string) => fsEntryKind(path),
findSymbols: (query: string, filter: string, limit: number) => findSymbols(query, filter, limit),
agentPrompt: (...args: unknown[]) => agentPrompt(...args),
},
};
});
@@ -35,7 +37,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
import { Composer } from "./Composer";
import { registerAgentContextSource } from "@/workbench/contributions";
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
import { composerDraft, updateComposer } from "./store";
import { composerDraft, sendMessage, setIdeContext, updateComposer, useAgents } from "./store";
import { emptyDraft, toPrompt } from "./composerModel";
const ID = "folders-test";
@@ -318,6 +320,7 @@ describe("Composer editing", () => {
describe("Composer current file", () => {
it("offers the focused editor's file until the draft references it", () => {
const view = {} as TextEditorHandle["view"];
act(() => setIdeContext(false));
act(() =>
useEditorRegistry.setState({ active: { view, ctx: { path: "/p/src/main.ts" } as TextEditorHandle["ctx"] } }),
);
@@ -336,6 +339,47 @@ describe("Composer current file", () => {
});
});
describe("Composer IDE context", () => {
it("sends the focused editor's file, or its selected lines, while IDE context is on", async () => {
const view = new EditorView({ doc: "a\nb\nc\nd\n" });
act(() => setIdeContext(true));
act(() =>
useEditorRegistry.setState({ active: { view, ctx: { path: "/p/src/main.ts" } as TextEditorHandle["ctx"] } }),
);
try {
renderComposer();
const toggle = screen.getByRole("button", { name: /IDE Context Enabled/ });
expect(toggle).toHaveAttribute("aria-pressed", "true");
expect(screen.queryByRole("button", { name: /main\.ts/ })).toBeNull();
expect(screen.getByTitle("src/main.ts is added to your request")).toHaveTextContent("Current File");
const send = async (text: string) => {
updateComposer(ID, { text });
await sendMessage(ID, false);
return agentPrompt.mock.lastCall?.[1];
};
expect(await send("explain")).toEqual({ text: "explain", files: ["/p/src/main.ts"], images: [] });
// Lines 2–3: the selection ends at the start of line 4.
view.dispatch({ selection: { anchor: 2, head: 6 } });
expect(await send("explain")).toEqual({
text: "explain\n\n@src/main.ts:2-3",
files: ["/p/src/main.ts"],
images: [],
});
// A draft that already references the file is sent as written.
expect(await send("see @src/main.ts:1")).toEqual({ text: "see @src/main.ts:1", files: [], images: [] });
fireEvent.click(toggle);
expect(useAgents.getState().ideContext).toBe(false);
expect(screen.getByRole("button", { name: /IDE Context Disabled/ })).toHaveAttribute("aria-pressed", "false");
expect(await send("explain")).toEqual({ text: "explain", files: [], images: [] });
} finally {
act(() => useEditorRegistry.setState({ active: null }));
view.destroy();
}
});
});
describe("Composer pasted code and terminal output", () => {
const paste = (box: HTMLElement, text: string) =>
act(() => {
+30
Переглянути файл
@@ -317,6 +317,36 @@ export function mentionOf(rel: string, lines?: { from: number; to: number }): st
export const isMentioned = (text: string, rel: string) =>
new RegExp(`@${escapeRe(rel)}(?![\\w./-])|@${escapeRe(rel)}:`).test(text);
/** The file in the focused editor and the lines selected in it, for IDE context. */
export interface IdeContext {
path: string;
rel: string;
/** 1-based lines of a non-empty selection. */
lines?: { from: number; to: number };
}
/**
* `draft` with the editor's current file added (as an attachment), or its selection as a
* line-range mention after the text; unchanged when the draft already references the file.
*/
export function withIdeContext(draft: ComposerDraft, context: IdeContext | null): ComposerDraft {
if (
!context ||
isMentioned(draft.text, context.rel) ||
draft.files.some((f) => f.path === context.path && f.attached)
)
return draft;
if (!context.lines)
return { ...draft, files: [...draft.files, { path: context.path, rel: context.rel, attached: true }] };
const mention = mentionOf(context.rel, context.lines);
const text = draft.text.trim();
return {
...draft,
text: text ? `${text}\n\n${mention}` : mention,
files: [...draft.files, { path: context.path, rel: context.rel }],
};
}
/** The prompt to send: attached files, files still mentioned in the text (each once), and the images. */
export function toPrompt(draft: ComposerDraft): AgentPrompt {
const seen = new Set<string>();
+31 -2
Переглянути файл
@@ -14,6 +14,7 @@ import type {
AgentImage,
AgentLimit,
AgentModelCatalog,
AgentPrompt,
AgentProvider,
AgentTask,
ExternalSession,
@@ -35,8 +36,10 @@ import {
isMentioned,
isPerModelOption,
toPrompt,
withIdeContext,
type ComposerDraft,
type FileRef,
type IdeContext,
} from "./composerModel";
import { withQuote } from "./conversation";
import {
@@ -127,6 +130,8 @@ interface AgentsState {
/** Side conversations by task id: kept out of the task list, discarded when their view closes. */
ephemeral: ReadonlySet<string>;
pinnedModels: string[];
/** Whether messages carry the editor's current file and selection. */
ideContext: boolean;
}
const DRAFT_KEY = "openidea.agents.draft.v2";
@@ -134,6 +139,7 @@ const HISTORY_KEY = "openidea.agents.history.v1";
const HISTORY_SIZE = 50;
const SESSION_LOCATION_KEY = "openidea.agents.sessionLocation.v1";
const PINNED_MODELS_KEY = "openidea.agents.pinnedModels.v1";
const IDE_CONTEXT_KEY = "openidea.agents.ideContext.v1";
function load<T>(key: string, fallback: T): T {
try {
@@ -198,6 +204,7 @@ export const useAgents = create<AgentsState>(() => ({
homeOpen: false,
ephemeral: new Set<string>(),
pinnedModels: load<string[]>(PINNED_MODELS_KEY, []),
ideContext: load<boolean>(IDE_CONTEXT_KEY, true),
scrollPositions: new Map(),
}));
@@ -972,7 +979,7 @@ export async function startTask(
const task = await call(
commands.agentCreate({
projectRoot,
prompt: toPrompt(composer),
prompt: promptOf(HOME, composer),
provider: draft.provider,
config,
isolation,
@@ -1086,6 +1093,28 @@ export async function importExternalSessions(
void showError(title, failures.join("\n"));
}
export function setIdeContext(on: boolean) {
useAgents.setState({ ideContext: on });
save(IDE_CONTEXT_KEY, on);
}
/** The IDE context of each mounted composer, by draft key. */
const ideContexts = new Map<string, () => IdeContext | null>();
/** Registers what composer `key` sends as IDE context; returns the unregister. */
export function provideIdeContext(key: string, context: () => IdeContext | null): () => void {
ideContexts.set(key, context);
return () => {
if (ideContexts.get(key) === context) ideContexts.delete(key);
};
}
/** The prompt of composer `key`, with the IDE context when it is on. */
function promptOf(key: string, composer: ComposerDraft): AgentPrompt {
const context = useAgents.getState().ideContext ? (ideContexts.get(key)?.() ?? null) : null;
return toPrompt(withIdeContext(composer, context));
}
function remember(text: string) {
if (!text) return;
const history = [text, ...useAgents.getState().history.filter((h) => h !== text)].slice(0, HISTORY_SIZE);
@@ -1098,7 +1127,7 @@ export async function sendMessage(task: string, now: boolean): Promise<void> {
const composer = composerDraft(task);
if (!canSend(composer)) return;
const started = generation;
await call(commands.agentPrompt(task, toPrompt(composer), now));
await call(commands.agentPrompt(task, promptOf(task, composer), now));
clearSubmittedComposer(task, composer, started);
}
+177 -11
Переглянути файл
@@ -11,7 +11,10 @@ const component = (name: string, options: Record<string, string>) =>
.map(([k, v]) => `<option name="${k}" value="${v}" />`)
.join("")}</component></application>`;
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
const settings = {
editor: { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} },
customKeymaps: {},
};
/** JetBrains Maple Mono's metrics (ascent 1.02em, descent 0.3em), for any family. */
const fontHeight = (_family: string, size: number) => Math.ceil(size * 1.02) + Math.ceil(size * 0.3);
@@ -55,7 +58,7 @@ const webstorm = {
describe("planJetBrainsImport", () => {
it("maps a WebStorm export to the settings it has, and lists what is left out", async () => {
const plan = await planJetBrainsImport(webstorm, editor, fontHeight);
const plan = await planJetBrainsImport(webstorm, settings, fontHeight);
const writes = Object.fromEntries(plan.writes);
const schemes = writes["editor.customSchemes"] as Record<string, { name: string; parent: string }>;
const [id, scheme] = Object.entries(schemes)[0]!;
@@ -73,6 +76,7 @@ describe("planJetBrainsImport", () => {
"files.ensureFinalNewline": true,
"editor.stickyScroll": false,
"editor.softWrap": false,
"console.softWrap": true,
"general.confirmExit": false,
});
expect(plan.rows).toContainEqual({
@@ -84,7 +88,7 @@ describe("planJetBrainsImport", () => {
label: "Remove trailing spaces on:",
value: "All lines",
});
expect(plan.skipped).toEqual(["Keymap", "Code Style", "Inspections", "Plugins"]);
expect(plan.skipped).toEqual(["Code Style options other than Tabs and Indents", "Inspections", "Plugins"]);
expect(plan.invalid).toEqual([]);
});
@@ -102,7 +106,7 @@ describe("planJetBrainsImport", () => {
}),
},
},
editor,
settings,
fontHeight,
);
expect(plan.writes).toEqual([
@@ -110,20 +114,24 @@ describe("planJetBrainsImport", () => {
["editor.lineHeight", 27],
["files.trimTrailingWhitespace", false],
["editor.softWrap", true],
["console.softWrap", true],
]);
expect(plan.skipped).toEqual([]);
});
it("re-importing replaces the earlier copy of a scheme and drops its edits", async () => {
const first = Object.fromEntries((await planJetBrainsImport(webstorm, editor, fontHeight)).writes);
const customs = first["editor.customSchemes"] as typeof editor.customSchemes;
const first = Object.fromEntries((await planJetBrainsImport(webstorm, settings, fontHeight)).writes);
const customs = first["editor.customSchemes"] as typeof settings.editor.customSchemes;
const [id] = Object.keys(customs);
const again = await planJetBrainsImport(
webstorm,
{
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
...settings,
editor: {
...settings.editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
},
},
fontHeight,
);
@@ -136,7 +144,7 @@ describe("planJetBrainsImport", () => {
it("falls back to the font size when the font cannot be measured", async () => {
const plan = await planJetBrainsImport(
{ entries: [], files: { "options/editor-font.xml": component("DefaultFont", { FONT_SIZE: "20" }) } },
editor,
settings,
() => undefined,
);
expect(plan.writes).toEqual([
@@ -145,8 +153,166 @@ describe("planJetBrainsImport", () => {
]);
});
it("imports the keymaps and makes the active one current", async () => {
const keymap =
'<keymap version="1" name="macOS copy" parent="Mac OS X 10.5+">' +
'<action id="NextTab"><keyboard-shortcut first-keystroke="ctrl right" /></action>' +
'<action id="GotoSuperMethod" /><action id="RunAnything" /></keymap>';
const active =
'<application><component name="KeymapManager"><active_keymap name="macOS copy" /></component></application>';
const bundle = {
entries: ["keymaps/macOS copy.xml", "keymaps/broken.xml"],
files: {
"keymaps/macOS copy.xml": keymap,
"keymaps/broken.xml": "<nope",
// The active keymap is stored per operating system; the host picks its own.
"options/mac/keymap.xml": active,
"options/windows/keymap.xml": active,
"options/linux/keymap.xml": active,
},
};
const plan = await planJetBrainsImport(bundle, settings);
const expected = {
name: "macOS copy",
parent: "intellij-macos",
overrides: { "editor.nextTab": ["Ctrl+Right"], "navigate.superMethod": [] },
};
expect(plan.writes).toEqual([
["customKeymaps", { "custom.macos-copy": expected }],
["keymap", "custom.macos-copy"],
]);
expect(plan.rows).toEqual([
{ label: "Keymap", value: "macOS copy" },
{ label: "Current keymap", value: "macOS copy" },
]);
expect(plan.unknownActions).toEqual(["RunAnything"]);
expect(plan.invalid).toEqual(["broken.xml"]);
// Importing again replaces the earlier copy and keeps the user's other keymaps.
const mine = { name: "Mine", parent: "vscode-macos", overrides: {} };
const again = await planJetBrainsImport(bundle, {
...settings,
customKeymaps: { "custom.macos-copy": { ...expected, overrides: {} }, "custom.mine": mine },
});
expect(again.writes[0]).toEqual(["customKeymaps", { "custom.macos-copy": expected, "custom.mine": mine }]);
});
it("imports the terminal font", async () => {
const plan = await planJetBrainsImport(
{
entries: [],
files: {
"options/terminal-font.xml": component("TerminalFontOptions", {
VERSION: "1",
FONT_SIZE: "17",
FONT_SIZE_2D: "17.0",
FONT_FAMILY: "MesloLGS NF",
LINE_SPACING: "1.1",
}),
},
},
settings,
);
expect(plan.writes).toEqual([
["terminal.useEditorFont", false],
["terminal.fontFamily", "MesloLGS NF"],
["terminal.fontSize", 17],
["terminal.lineHeight", 1.1],
]);
});
it("imports tabs and indents of the current code style scheme onto the languages' own styles", async () => {
const scheme = (name: string, body: string) => `<code_scheme name="${name}" version="173">${body}</code_scheme>`;
const plan = await planJetBrainsImport(
{
entries: ["codestyles/Default.xml", "codestyles/Team.xml"],
files: {
"options/code.style.schemes.xml": component("CodeStyleSchemeSettings", { CURRENT_SCHEME_NAME: "Team" }),
"codestyles/Default.xml": scheme(
"Default",
'<codeStyleSettings language="Python"><indentOptions><option name="INDENT_SIZE" value="8" /></indentOptions></codeStyleSettings>',
),
"codestyles/Team.xml": scheme(
"Team",
'<option name="RIGHT_MARGIN" value="100" />' +
'<option name="OTHER_INDENT_OPTIONS"><value><option name="TAB_SIZE" value="8" />' +
'<option name="USE_TAB_CHARACTER" value="true" /></value></option>' +
'<JSCodeStyleSettings version="0"><option name="USE_SEMICOLON_AFTER_STATEMENT" value="false" /></JSCodeStyleSettings>' +
'<codeStyleSettings language="TypeScript"><option name="SPACE_WITHIN_BRACKETS" value="true" />' +
'<indentOptions><option name="INDENT_SIZE" value="2" /><option name="CONTINUATION_INDENT_SIZE" value="2" />' +
'<option name="TAB_SIZE" value="2" /></indentOptions></codeStyleSettings>' +
'<codeStyleSettings language="HTML"><option name="LINE_COMMENT_AT_FIRST_COLUMN" value="false" />' +
'<indentOptions><option name="USE_TAB_CHARACTER" value="true" /></indentOptions></codeStyleSettings>' +
'<codeStyleSettings language="Brainfuck"><indentOptions><option name="INDENT_SIZE" value="3" /></indentOptions></codeStyleSettings>',
),
},
},
{
...settings,
editor: {
...settings.editor,
codeStyle: { languages: { typescript: { hardWrapAt: 90 }, go: { tabSize: 8 } } },
},
},
);
expect(plan.writes).toEqual([
["editor.codeStyle.hardWrapAt", 100],
["editor.tabSize", 8],
["editor.insertSpaces", false],
[
"editor.codeStyle.languages",
{
typescript: { hardWrapAt: 90, indent: 2, tabSize: 2 },
typescriptreact: { indent: 2, tabSize: 2 },
html: { useTab: true, lineCommentAtFirstColumn: false },
go: { tabSize: 8 },
},
],
]);
expect(plan.rows).toContainEqual({ label: "Code Style › TypeScript", value: "Indent 2, Tab size 2" });
expect(plan.rows).toContainEqual({ label: "Use tab character", value: "On" });
expect(plan.skipped).toEqual(["Code Style options other than Tabs and Indents"]);
});
it("imports the editor options that have a setting here", async () => {
const xml =
"<application>" +
component("EditorSettings", {
IS_SMOOTH_CARET_BLINKING: "true",
IS_BLOCK_CURSOR: "true",
ARE_LINE_NUMBERS_SHOWN: "false",
LINE_NUMERATION: "HYBRID",
SHOW_BREADCRUMBS_ABOVE: "true",
CARET_BLINKING_PERIOD: "700",
IS_ANIMATED_SCROLLING: "false",
}).replace(/<\/?application>/g, "") +
component("CodeInsightSettings", {
AUTOINSERT_PAIR_QUOTE: "false",
REFORMAT_ON_PASTE: "2",
SMART_BACKSPACE: "1",
PARAMETER_INFO_DELAY: "500",
COMPLETION_CASE_SENSITIVE: "2",
}).replace(/<\/?application>/g, "") +
"</application>";
const plan = await planJetBrainsImport({ entries: [], files: { "options/editor.xml": xml } }, settings);
expect(Object.fromEntries(plan.writes)).toEqual({
"editor.appearance.lineNumberMode": "hybrid",
"editor.breadcrumbs.placement": "top",
"editor.appearance.smoothCaretBlinking": true,
"editor.appearance.blockCaret": true,
"editor.appearance.lineNumbers": false,
"editor.appearance.caretBlinkPeriod": 700,
"editor.smartKeys.pairQuotes": false,
"editor.completion.parameterInfoDelay": 500,
"editor.smartKeys.reformatOnPaste": "indentBlock",
"editor.smartKeys.backspaceUnindent": "nearest",
});
expect(plan.rows).toContainEqual({ label: "Unindent", value: "To nearest indent position" });
expect(plan.rows).toContainEqual({ label: "Show line numbers", value: "Hybrid" });
});
it("skips colour schemes that cannot be read", async () => {
const plan = await planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
const plan = await planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, settings);
expect(plan.invalid).toEqual(["broken.icls"]);
expect(plan.writes).toEqual([]);
});
+1 -1
Переглянути файл
@@ -58,7 +58,7 @@ it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s
expect(screen.getByText("Monaco")).toBeInTheDocument();
expect(screen.getByText("17")).toBeInTheDocument();
expect(screen.getAllByText("Custom")).toHaveLength(2);
expect(screen.getByText(/Not imported:/)).toHaveTextContent("Keymap, Plugins");
expect(screen.getByText(/Not imported:/)).toHaveTextContent("Plugins");
expect(set).not.toHaveBeenCalled();
await act(async () => {
fireEvent.click(screen.getByRole("button", { name: button }));
+79
Переглянути файл
@@ -15,6 +15,7 @@ import {
installMenuBridge,
menuAccelerator,
menuActionIds,
returnFocusAfterMenu,
routeMenuEvent,
} from "../menuBridge";
@@ -54,6 +55,84 @@ describe("menu state from the frontend", () => {
}
});
it("pushes enablement once when the window loses focus, for its Settings window (#3625)", async () => {
vi.useFakeTimers();
vi.spyOn(ipc, "isTauri").mockReturnValue(true);
const hasFocus = vi.spyOn(document, "hasFocus").mockReturnValue(true);
vi.spyOn(ipc.commands, "appBuildInfo").mockRejectedValue(new Error("No build info in tests"));
vi.spyOn(ipc.commands, "menuConfigure").mockResolvedValue();
vi.spyOn(ipc.commands, "menuModel").mockResolvedValue([
{ kind: "action", id: "test.menuBlur", label: "Test", hint: null, arg: null, checked: null },
]);
const pushDisabled = vi.spyOn(ipc.commands, "menuSetDisabled").mockResolvedValue();
const offAction = registerAction({ id: "test.menuBlur", title: "Test", when: "testMenuBlurEditor", run: () => {} });
setContext("testMenuBlurEditor", true);
const dispose = installMenuBridge();
try {
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).toHaveBeenCalledExactlyOnceWith([]);
pushDisabled.mockClear();
// Focus moves to the Settings window: the editor loses focus, then the window blurs.
hasFocus.mockReturnValue(false);
setContext("testMenuBlurEditor", false);
window.dispatchEvent(new Event("blur"));
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).toHaveBeenCalledExactlyOnceWith(["test.menuBlur"]);
pushDisabled.mockClear();
// Later changes in a background window are not pushed.
setContext("testMenuBlurEditor", true);
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).not.toHaveBeenCalled();
} finally {
dispose();
offAction();
clearContext("testMenuBlurEditor");
vi.useRealTimers();
vi.restoreAllMocks();
}
});
it("brings Settings back once the dialog opened from its menu closes (#3625)", async () => {
vi.useFakeTimers();
vi.spyOn(document, "hasFocus").mockReturnValue(true);
const focusSettings = vi.fn(async () => {});
try {
// About opens a dialog: Settings waits under it.
const about = returnFocusAfterMenu(
Promise.resolve(true)
.then(() => setContext("popupOpen", true))
.then(() => true),
focusSettings,
);
await vi.advanceTimersByTimeAsync(1000);
expect(focusSettings).not.toHaveBeenCalled();
setContext("popupOpen", false);
await about;
expect(focusSettings).toHaveBeenCalledOnce();
// An action that opens nothing: Settings comes back right away.
focusSettings.mockClear();
const saveAll = returnFocusAfterMenu(Promise.resolve(true), focusSettings);
await vi.advanceTimersByTimeAsync(300);
await saveAll;
expect(focusSettings).toHaveBeenCalledOnce();
// Focus moved on (a new window or a native dialog): Settings stays where it is.
focusSettings.mockClear();
vi.mocked(document.hasFocus).mockReturnValue(false);
const open = returnFocusAfterMenu(Promise.resolve(true), focusSettings);
await vi.advanceTimersByTimeAsync(300);
await open;
expect(focusSettings).not.toHaveBeenCalled();
} finally {
clearContext("popupOpen");
vi.useRealTimers();
vi.restoreAllMocks();
}
});
it("lists registered tool windows by title and saved layouts", () => {
localStorage.clear();
_reloadLayouts();
+2
Переглянути файл
@@ -8,6 +8,8 @@ vi.mock("@tauri-apps/api/core", () => ({
Channel: class {
onmessage: (p: unknown) => void = () => {};
},
// Balloons are mirrored to a system notification (`showSystemNotification`).
invoke: async () => null,
}));
type Channel = { onmessage: (p: UpdateProgress) => void };
+50
Переглянути файл
@@ -748,3 +748,53 @@ describe("explicit project-window requests", () => {
}
});
});
describe("trust is asked before a new project window opens", () => {
const openProjectPath = (arg: unknown) =>
windowActions()
.find((a) => a.id === "file.openProjectPath")!
.run({ arg } as never);
const newWindowEntries: [string, () => unknown][] = [
["Open… from a project window", () => openProjectInWindow("/p/b", false)],
["Open in New Window", () => openProjectInWindow("/p/b", true)],
["Open project in: New Window", () => openProjectWithPolicy("/p/b")],
["a plugin's new-window request", () => openProjectPath({ path: "/p/b", newWindow: true })],
];
it.each(newWindowEntries)("%s asks in this window first", async (_, open) => {
useProject.setState({ ...projectState("/p/a"), settings: { general: { openProjectIn: "new" } } } as never);
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
await open();
expect(confirmProjectTrust).toHaveBeenCalledWith("/p/b", "local");
expect(vi.mocked(confirmProjectTrust).mock.invocationCallOrder[0]).toBeLessThan(
windowOpenProject.mock.invocationCallOrder[0]!,
);
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", true, []);
});
it.each(newWindowEntries)("%s opens no window when the user chooses Don't Open", async (_, open) => {
useProject.setState({ ...projectState("/p/a"), settings: { general: { openProjectIn: "new" } } } as never);
vi.mocked(confirmProjectTrust).mockRejectedValueOnce(new IpcError({ kind: "cancelled", message: "Cancelled" }));
await open();
expect(windowOpenProject).not.toHaveBeenCalled();
expect(notify).not.toHaveBeenCalled();
expect(useProject.getState().project?.root).toBe("/p/a");
});
it("leaves a WSL folder to the remote window, which asks about the distribution's project", async () => {
useProject.setState(projectState("/p/a") as never);
wslResolve.mockResolvedValue({ target: { kind: "wsl", distro: "Debian" }, path: "/srv/app" });
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
await openProjectInWindow("\\\\wsl.localhost\\Debian\\srv\\app", true);
expect(confirmProjectTrust).not.toHaveBeenCalled();
expect(windowOpenProject).toHaveBeenCalled();
});
it("asks only once, from openProject, when the project opens in this window", async () => {
windowOpenProject.mockResolvedValue(ok({ kind: "current" }));
await openProjectInWindow("/p/b", false);
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", false, []);
expect(confirmProjectTrust).not.toHaveBeenCalled();
expect(openProject).toHaveBeenCalledWith("/p/b");
});
});
+123
Переглянути файл
@@ -0,0 +1,123 @@
/**
* JetBrains option names (as the IDE writes them to `options/editor.xml` and
* `codestyles/*.xml`) and the OpenIDEA settings of the same meaning. Each entry
* carries the label the option has in Settings, for the import confirmation.
*/
type Mapped = readonly [key: string, label: string];
/** `<component name="EditorSettings">`: on/off options. */
export const EDITOR_FLAGS: Record<string, Mapped> = {
IS_WHEEL_FONTCHANGE_ENABLED: ["editor.general.wheelZoom", "Change font size with Ctrl/Command+Mouse Wheel"],
IS_DND_ENABLED: ["editor.general.dragAndDrop", "Enable drag-and-drop functionality in editor"],
USE_CUSTOM_SOFT_WRAP_INDENT: ["editor.general.softWrapIndent", "Use original line's indent for wrapped parts"],
ADDITIONAL_PAGE_AT_BOTTOM: ["editor.general.scrollPastEnd", "Show virtual space at file bottom"],
KEEP_TRAILING_SPACE_ON_CARET_LINE: ["editor.general.keepTrailingOnCaretLine", "Keep trailing spaces on caret line"],
REMOVE_TRAILING_BLANK_LINES: [
"editor.general.removeTrailingBlankLines",
"Remove trailing blank lines at the end of saved files",
],
IS_CARET_BLINKING: ["editor.appearance.caretBlinking", "Caret blinking (ms):"],
IS_SMOOTH_CARET_BLINKING: ["editor.appearance.smoothCaretBlinking", "Use smooth caret blinking"],
IS_BLOCK_CURSOR: ["editor.appearance.blockCaret", "Use block caret"],
IS_SMOOTH_CARET_MOVEMENT: ["editor.appearance.smoothCaretMovement", "Use smooth caret movement"],
IS_RIGHT_MARGIN_SHOWN: [
"editor.appearance.hardWrapGuides",
"Show hard wrap and visual guides (configured in Code Style options)",
],
ARE_LINE_NUMBERS_SHOWN: ["editor.appearance.lineNumbers", "Show line numbers"],
IS_LEADING_WHITESPACES_SHOWN: ["editor.appearance.whitespaceLeading", "Leading"],
IS_INNER_WHITESPACES_SHOWN: ["editor.appearance.whitespaceInner", "Inner"],
IS_TRAILING_WHITESPACES_SHOWN: ["editor.appearance.whitespaceTrailing", "Trailing"],
IS_INDENT_GUIDES_SHOWN: ["editor.appearance.indentGuides", "Show indent guides"],
SHOW_INTENTION_BULB: ["editor.appearance.intentionBulb", "Show intention bulb"],
ENABLE_RENDERED_DOC: ["editor.appearance.renderDocComments", "Render documentation comments"],
SHOW_BREADCRUMBS: ["editor.breadcrumbs.show", "Show breadcrumbs:"],
IS_FOLDING_OUTLINE_SHOWN: ["editor.folding.showOutline", "Show code folding outline"],
SMART_HOME: ["editor.smartKeys.smartHome", "Home moves caret to first non-whitespace character"],
IS_CAMEL_WORDS: ["editor.smartKeys.camelHumps", 'Use "CamelHumps" words'],
IS_HIGHLIGHT_SELECTION_OCCURRENCES: ["editor.codeEditing.highlightSelection", "Occurrences of selected text"],
SHOW_QUICK_DOC_ON_MOUSE_OVER_ELEMENT: ["editor.codeEditing.quickDocOnHover", "Show quick documentation on hover"],
INSERT_PARENTHESES_AUTOMATICALLY: [
"editor.completion.insertParentheses",
"Insert parentheses automatically when applicable",
],
};
/** `<component name="EditorSettings">`: numbers. */
export const EDITOR_NUMBERS: Record<string, Mapped> = {
CARET_BLINKING_PERIOD: ["editor.appearance.caretBlinkPeriod", "Caret blinking (ms):"],
STICKY_LINES_LIMIT: ["editor.codeEditing.stickyLinesMax", "Maximum number of lines"],
TOOLTIPS_DELAY_MS: ["editor.codeEditing.quickDocDelay", "Tooltip delay"],
};
/** `<component name="CodeInsightSettings">`: on/off options. */
export const CODE_INSIGHT_FLAGS: Record<string, Mapped> = {
AUTOINSERT_PAIR_BRACKET: ["editor.smartKeys.pairBrackets", "Insert paired brackets (), [], {}"],
AUTOINSERT_PAIR_QUOTE: ["editor.smartKeys.pairQuotes", "Insert pair quote"],
SURROUND_SELECTION_ON_QUOTE_TYPED: [
"editor.smartKeys.surroundSelection",
"Surround selection on typing quote or brace",
],
TAB_EXITS_BRACKETS_AND_QUOTES: ["editor.smartKeys.tabOutOfPair", "Jump outside closing bracket/quote with Tab"],
SMART_INDENT_ON_ENTER: ["editor.smartKeys.smartIndent", "Smart indent"],
JAVADOC_STUB_ON_ENTER: ["editor.smartKeys.insertDocStub", "Insert documentation comment stub"],
HIGHLIGHT_IDENTIFIER_UNDER_CARET: ["editor.codeEditing.highlightUsages", "Usages of element at caret"],
HIGHLIGHT_BRACES: ["editor.codeEditing.highlightBraces", "Matched brace"],
AUTO_POPUP_COMPLETION_LOOKUP: ["editor.completion.autoPopup", "Show suggestions as you type"],
AUTOCOMPLETE_ON_CODE_COMPLETION: ["editor.completion.autoInsertSingle", "Automatically insert single suggestions"],
AUTO_POPUP_JAVADOC_INFO: ["editor.completion.showDocumentation", "Show the documentation popup in"],
AUTO_POPUP_PARAMETER_INFO: ["editor.completion.parameterInfo", "Show the parameter info popup in"],
};
/** `<component name="CodeInsightSettings">`: numbers. */
export const CODE_INSIGHT_NUMBERS: Record<string, Mapped> = {
JAVADOC_INFO_DELAY: ["editor.completion.documentationDelay", "Show the documentation popup in"],
PARAMETER_INFO_DELAY: ["editor.completion.parameterInfoDelay", "Show the parameter info popup in"],
};
/** `REFORMAT_ON_PASTE` (IDEA's `CodeInsightSettings` constants) → `editor.smartKeys.reformatOnPaste`, its label. */
export const REFORMAT_ON_PASTE: Record<string, Mapped> = {
"1": ["none", "None"],
"2": ["indentBlock", "Indent Block"],
"3": ["indentEachLine", "Indent Each Line"],
};
/** `SMART_BACKSPACE` (IDEA's `SmartBackspaceMode` ordinals) → `editor.smartKeys.backspaceUnindent`, its label. */
export const SMART_BACKSPACE: Record<string, Mapped> = {
"0": ["none", "Disabled"],
"1": ["nearest", "To nearest indent position"],
"2": ["autoindent", "To proper indent position"],
};
/** `<codeStyleSettings language=…>` → the language ids that share that code style here. */
export const CODE_STYLE_LANGUAGES: Record<string, readonly string[]> = {
JAVA: ["java"],
kotlin: ["kotlin"],
Groovy: ["groovy"],
Scala: ["scala"],
JavaScript: ["javascript", "javascriptreact"],
TypeScript: ["typescript", "typescriptreact"],
Vue: ["vue"],
HTML: ["html"],
XML: ["xml"],
CSS: ["css"],
SCSS: ["scss"],
SASS: ["sass"],
LESS: ["less"],
JSON: ["json", "jsonc"],
yaml: ["yaml"],
TOML: ["toml"],
Markdown: ["markdown"],
Python: ["python"],
go: ["go"],
Rust: ["rust"],
PHP: ["php"],
ruby: ["ruby"],
Dart: ["dart"],
Swift: ["swift"],
"C#": ["csharp"],
Lua: ["lua"],
SQL: ["sql"],
"Shell Script": ["shellscript"],
};
+187 -17
Переглянути файл
@@ -1,21 +1,32 @@
/**
* Import Settings… with a JetBrains `settings.zip`: maps the archive's colour
* schemes and the editor / general options OpenIDEA has to settings writes, after
* a confirmation listing them. Only keys present in the archive are written
* (JetBrains leaves defaults out). Keymaps, code styles and the rest are listed
* as not imported.
* schemes, keymaps, fonts, tabs and indents, and the editor / general options
* OpenIDEA has to settings writes, after a confirmation listing them. Only keys
* present in the archive are written (JetBrains leaves defaults out). The rest
* is listed as not imported.
*/
import { Fragment } from "react";
import type { JetBrainsSettings } from "@/bindings";
import type { CustomKeymap, JetBrainsSettings, LanguageCodeStyle } from "@/bindings";
import { customSchemes } from "@/platform/colorScheme";
import { createFontProbeCanvas, fontsLoaded, monoFontFamily } from "@/platform/fonts";
import { tx } from "@/platform/i18n";
import { importScheme, parseIcls } from "@/platform/icls";
import { addIdeaKeymap, parseIdeaKeymap } from "@/platform/ideaKeymap";
import { call, commands } from "@/platform/ipc";
import { guessOs } from "@/platform/platformInfo";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { ask } from "@/workbench/messages";
import styles from "./app.module.css";
import {
CODE_INSIGHT_FLAGS,
CODE_INSIGHT_NUMBERS,
CODE_STYLE_LANGUAGES,
EDITOR_FLAGS,
EDITOR_NUMBERS,
REFORMAT_ON_PASTE,
SMART_BACKSPACE,
} from "./jetbrainsOptions";
export interface JetBrainsImportPlan {
/** Settings writes, in order: `settingsSet("global", key, JSON.stringify(value))`. */
@@ -24,15 +35,22 @@ export interface JetBrainsImportPlan {
rows: { label: string; value: string }[];
/** Categories present in the archive that are not imported (translated). */
skipped: string[];
/** `.icls` files that could not be read. */
/** Colour scheme and keymap files that could not be read. */
invalid: string[];
/** IDEA action ids the imported keymaps bind that have no counterpart here. */
unknownActions: string[];
}
interface EditorState {
fontFamily: string;
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
/** The settings the import builds on (`settingsGetGlobal`). */
interface CurrentSettings {
editor: {
fontFamily: string;
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
codeStyle?: { languages?: Record<string, LanguageCodeStyle> };
};
customKeymaps?: Record<string, CustomKeymap>;
}
const USER_PREFIX = "_@user_";
@@ -93,12 +111,39 @@ async function measuredFontHeight(family: string, size: number): Promise<number
}
}
/** `<option name value>` children of `parent`. */
function optionValues(parent: Element | null | undefined): Map<string, string> {
const out = new Map<string, string>();
for (const o of Array.from(parent?.children ?? [])) {
const name = o.getAttribute("name");
const value = o.getAttribute("value");
if (o.tagName === "option" && name && value !== null) out.set(name, value);
}
return out;
}
const childOf = (parent: Element, tag: string, name?: string) =>
Array.from(parent.children).find((c) => c.tagName === tag && (name === undefined || c.getAttribute("name") === name));
/** The code style scheme called `name` among `codestyles/*.xml`. */
function codeScheme(files: Record<string, string>, name: string): Element | undefined {
for (const [file, text] of Object.entries(files)) {
if (!file.startsWith("codestyles/")) continue;
const doc = new DOMParser().parseFromString(text, "application/xml");
const root = doc.documentElement;
if (!doc.querySelector("parsererror") && root.tagName === "code_scheme" && root.getAttribute("name") === name)
return root;
}
return undefined;
}
export async function planJetBrainsImport(
bundle: JetBrainsSettings,
editor: EditorState,
current: CurrentSettings,
fontHeight: FontHeight = measuredFontHeight,
): Promise<JetBrainsImportPlan> {
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [] };
const { editor } = current;
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [], unknownActions: [] };
const add = (key: string, value: string | number | boolean | undefined, label: string, shown?: string) => {
if (value === undefined) return;
plan.writes.push([key, value]);
@@ -134,6 +179,33 @@ export async function planJetBrainsImport(
if (id) add("editor.colorScheme", id, tx("Current color scheme"), customs[id]?.name);
}
let keymaps = current.customKeymaps ?? {};
const importedKeymaps = new Map<string, string>(); // name in the keymap file → keymap id
for (const [file, text] of Object.entries(bundle.files)) {
if (!file.startsWith("keymaps/")) continue;
let parsed;
try {
parsed = parseIdeaKeymap(text);
} catch {
plan.invalid.push(file.slice("keymaps/".length));
continue;
}
// Overwrites an earlier import of the same keymap, as colour schemes do.
const next = addIdeaKeymap(keymaps, parsed);
keymaps = next.customs;
importedKeymaps.set(parsed.name, next.id);
plan.unknownActions.push(...parsed.unknownActions.filter((id) => !plan.unknownActions.includes(id)));
plan.rows.push({ label: tx("Keymap"), value: keymaps[next.id]?.name ?? parsed.name });
}
if (importedKeymaps.size) {
plan.writes.push(["customKeymaps", keymaps]);
// The active keymap is stored per operating system; a bundled one keeps OpenIDEA's choice.
const os = { macos: "mac", windows: "windows", linux: "linux", web: "" }[guessOs()];
const active = options(bundle.files[`options/${os}/keymap.xml`], "KeymapManager", "active_keymap").get("");
const id = importedKeymaps.get(active ?? "");
if (id) add("keymap", id, tx("Current keymap"), keymaps[id]?.name);
}
const font = options(bundle.files["options/editor-font.xml"], "DefaultFont");
const family = font.get("FONT_FAMILY")?.trim() || undefined;
add("editor.fontFamily", family, tx("Font"));
@@ -149,6 +221,21 @@ export async function planJetBrainsImport(
}
add("editor.ligatures", bool(font.get("USE_LIGATURES")), tx("Enable ligatures"));
const terminal = options(bundle.files["options/terminal-font.xml"], "TerminalFontOptions");
const terminalFamily = terminal.get("FONT_FAMILY")?.trim() || undefined;
const terminalSize = num(terminal.get("FONT_SIZE"));
// A terminal font of its own: stop following the editor font (the font rows below say so).
if (terminalFamily || terminalSize) plan.writes.push(["terminal.useEditorFont", false]);
add("terminal.fontFamily", terminalFamily, tx("Terminal font"));
add("terminal.fontSize", terminalSize, tx("Terminal font size"));
add("terminal.lineHeight", num(terminal.get("LINE_SPACING")), tx("Terminal line height"));
add("terminal.columnWidth", num(terminal.get("COLUMN_SPACING")), tx("Terminal column width"));
add(
"terminal.fallbackFontFamily",
terminal.get("SECONDARY_FONT_FAMILY")?.trim() || undefined,
tx("Terminal fallback font"),
);
const ed = options(bundle.files["options/editor.xml"], "EditorSettings");
const strip = ed.get("STRIP_TRAILING_SPACES"); // None | Changed | Whole
if (strip === "Changed" || strip === "Whole") {
@@ -175,13 +262,95 @@ export async function planJetBrainsImport(
wraps === undefined ? undefined : wraps.split(",").includes("MAIN_EDITOR"),
tx("Soft-wrap files"),
);
add(
"console.softWrap",
wraps === undefined ? undefined : wraps.split(",").includes("CONSOLE"),
tx("Use soft wraps in console"),
);
add("editor.general.softWrapFiles", ed.get("SOFT_WRAP_FILE_MASKS")?.trim() || undefined, tx("File patterns"));
const numeration = { ABSOLUTE: "Absolute", RELATIVE: "Relative", HYBRID: "Hybrid" }[ed.get("LINE_NUMERATION") ?? ""];
add("editor.appearance.lineNumberMode", numeration?.toLowerCase(), tx("Show line numbers"), tx(numeration ?? ""));
const above = bool(ed.get("SHOW_BREADCRUMBS_ABOVE"));
add(
"editor.breadcrumbs.placement",
above === undefined ? undefined : above ? "top" : "bottom",
tx("Show breadcrumbs:"),
tx(above ? "Top" : "Bottom"),
);
const insight = options(bundle.files["options/editor.xml"], "CodeInsightSettings");
for (const [source, flags, numbers] of [
[ed, EDITOR_FLAGS, EDITOR_NUMBERS],
[insight, CODE_INSIGHT_FLAGS, CODE_INSIGHT_NUMBERS],
] as const) {
for (const [name, [key, label]] of Object.entries(flags)) add(key, bool(source.get(name)), tx(label));
for (const [name, [key, label]] of Object.entries(numbers)) add(key, num(source.get(name)), tx(label));
}
const paste = REFORMAT_ON_PASTE[insight.get("REFORMAT_ON_PASTE") ?? ""];
add("editor.smartKeys.reformatOnPaste", paste?.[0], tx("Reformat on paste"), tx(paste?.[1] ?? ""));
const backspace = SMART_BACKSPACE[insight.get("SMART_BACKSPACE") ?? ""];
add("editor.smartKeys.backspaceUnindent", backspace?.[0], tx("Unindent"), tx(backspace?.[1] ?? ""));
// Tabs and Indents of the current code style scheme; its other formatting options have no setting here.
const schemeName =
options(bundle.files["options/code.style.schemes.xml"], "CodeStyleSchemeSettings").get("CURRENT_SCHEME_NAME") ??
"Default";
const scheme = codeScheme(bundle.files, schemeName);
if (scheme) {
const root = optionValues(scheme);
add("editor.codeStyle.hardWrapAt", num(root.get("RIGHT_MARGIN")), tx("Hard wrap at"));
add(
"editor.codeStyle.detectIndents",
bool(root.get("AUTODETECT_INDENTS")),
tx("Detect and use existing file indents for editing"),
);
// "Other File Types": the indent of languages without a code style of their own.
const other = optionValues(childOf(childOf(scheme, "option", "OTHER_INDENT_OPTIONS") ?? scheme, "value"));
add("editor.tabSize", num(other.get("TAB_SIZE")), tx("Tab size"));
const otherTabs = bool(other.get("USE_TAB_CHARACTER"));
add(
"editor.insertSpaces",
otherTabs === undefined ? undefined : !otherTabs,
tx("Use tab character"),
otherTabs === undefined ? undefined : onOff(otherTabs),
);
const languages = { ...editor.codeStyle?.languages };
let changed = false;
for (const block of Array.from(scheme.children)) {
const ids = CODE_STYLE_LANGUAGES[block.getAttribute("language") ?? ""];
if (block.tagName !== "codeStyleSettings" || !ids) continue;
const own = optionValues(block);
const indent = optionValues(childOf(block, "indentOptions"));
const style: Partial<LanguageCodeStyle> = {};
const shown: string[] = [];
const set = <K extends keyof LanguageCodeStyle>(
key: K,
value: LanguageCodeStyle[K] | undefined,
label: string,
) => {
if (value === undefined) return;
style[key] = value;
shown.push(`${tx(label)} ${typeof value === "boolean" ? onOff(value) : value}`);
};
set("indent", num(indent.get("INDENT_SIZE")), "Indent");
set("tabSize", num(indent.get("TAB_SIZE")), "Tab size");
set("useTab", bool(indent.get("USE_TAB_CHARACTER")), "Use tab character");
set("hardWrapAt", num(own.get("RIGHT_MARGIN")), "Hard wrap at");
set("lineCommentAtFirstColumn", bool(own.get("LINE_COMMENT_AT_FIRST_COLUMN")), "Line comment at first column");
set("lineCommentAddSpace", bool(own.get("LINE_COMMENT_ADD_SPACE")), "Add a space at line comment start");
if (!shown.length) continue;
for (const id of ids) languages[id] = { ...languages[id], ...style } as LanguageCodeStyle;
changed = true;
plan.rows.push({ label: `${tx("Code Style")} › ${block.getAttribute("language")}`, value: shown.join(", ") });
}
if (changed) plan.writes.push(["editor.codeStyle.languages", languages]);
}
const general = options(bundle.files["options/ide.general.xml"], "GeneralSettings");
add("general.confirmExit", bool(general.get("confirmExit")), tx("Confirm before exiting the IDE"));
const has = (prefix: string) => bundle.entries.some((e) => e.startsWith(prefix));
if (has("keymaps/")) plan.skipped.push(tx("Keymap"));
if (has("codestyles/")) plan.skipped.push(tx("Code Style"));
if (has("codestyles/")) plan.skipped.push(tx("Code Style options other than Tabs and Indents"));
if (has("templates/")) plan.skipped.push(tx("Live templates"));
if (has("inspection/")) plan.skipped.push(tx("Inspections"));
if (has("installed.txt")) plan.skipped.push(tx("Plugins"));
@@ -190,6 +359,7 @@ export async function planJetBrainsImport(
function Summary({ plan }: { plan: JetBrainsImportPlan }) {
const left = [...plan.skipped, ...plan.invalid];
const unknown = plan.unknownActions;
return (
<div className={styles.importSummary}>
<div>{tx("These settings will be imported:")}</div>
@@ -206,6 +376,7 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
{tx("Not imported:")} {left.join(", ")}
</div>
)}
{unknown.length > 0 && <div>{tx`Not available in OpenIDEA (${unknown.length}): ${unknown.join(", ")}.`}</div>}
</div>
);
}
@@ -213,8 +384,7 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
/** Reads `path`, asks, then writes the mapped settings to the global layer. */
export async function importJetBrainsSettings(path: string) {
const bundle = await call(commands.settingsReadJetbrains(path));
const { editor } = await commands.settingsGetGlobal();
const plan = await planJetBrainsImport(bundle, editor);
const plan = await planJetBrainsImport(bundle, await commands.settingsGetGlobal());
if (!plan.writes.length) {
notifications().notify({
level: "warning",
+53 -4
Переглянути файл
@@ -8,7 +8,7 @@
* equivalent while the JS keymap stays the only dispatcher (see src-tauri/src/menu.rs).
*/
import { executeActionFrom, getAction, isActionEnabled, useActions } from "@/platform/actions";
import { useContextKeys } from "@/platform/context";
import { getContext, useContextKeys } from "@/platform/context";
import { keysWithPrefix, t, tx, useI18n } from "@/platform/i18n";
import { commands, isTauri, type DynamicItem, type MenuConfig, type MenuNode } from "@/platform/ipc";
import {
@@ -32,6 +32,8 @@ export const MENU_EVENT = "openidea://menu";
export interface MenuRoute {
action: string;
arg?: string | null;
/** The window in front when the item was chosen, if it is not this one (this window's Settings). */
returnTo?: string;
}
export function isMenuRoute(v: unknown): v is MenuRoute {
@@ -47,6 +49,36 @@ export function routeMenuEvent(
return run(payload.action, payload.arg ?? undefined);
}
/** How long an action chosen from the menu may take to open its dialog or popup. */
const OPEN_DELAY_MS = 300;
const layersClosed = () =>
new Promise<void>((resolve) => {
if (!getContext().popupOpen) return resolve();
const off = useContextKeys.subscribe((ctx) => {
if (ctx.popupOpen) return;
off();
resolve();
});
});
/**
* After an item chosen in this window's Settings window ran here (the backend brought this window
* forward): once the dialog or popup it opened closes, or right away if it opened none, Settings comes
* back to the front, as IDEA's Settings dialog stays under the dialogs opened from the menu. Not when
* focus has moved on (a new window, a native dialog).
*/
export async function returnFocusAfterMenu(
ran: Promise<boolean>,
focusWindow: () => Promise<void>,
delay = OPEN_DELAY_MS,
): Promise<void> {
await ran;
await new Promise((r) => setTimeout(r, delay));
await layersClosed();
if (document.hasFocus()) await focusWindow();
}
/**
* Keymap key names a macOS key equivalent can show. Mirrors the names muda's accelerator
* parser accepts: Tauri drops an accelerator it cannot parse, and the item shows no shortcut.
@@ -167,22 +199,36 @@ export function installMenuBridge(): () => void {
void import("@tauri-apps/api/webviewWindow").then(async ({ getCurrentWebviewWindow }) => {
// Window-scoped: a global `listen` would also receive other windows' menu events.
const off = await getCurrentWebviewWindow().listen(MENU_EVENT, ({ payload }) => void routeMenuEvent(payload));
const off = await getCurrentWebviewWindow().listen(MENU_EVENT, ({ payload }) => {
const ran = routeMenuEvent(payload);
const returnTo = isMenuRoute(payload) ? payload.returnTo : undefined;
if (returnTo)
void returnFocusAfterMenu(ran, async () => {
const { Window } = await import("@tauri-apps/api/window");
await (await Window.getByLabel(returnTo))?.setFocus();
}).catch(() => {});
});
if (disposed) off();
else unlisten = off;
});
// Enablement of the native items follows this window's context (IDEA greys out
// what cannot run). Recomputed shortly after context changes, sent only when it changed.
// Also once on blur: the menu still runs here while this window's Settings window is focused,
// with nothing focused here (editor actions disabled). The backend ignores it for other windows.
let ids: Set<string> | null = null;
let lastDisabled = "";
let forceEnablement = false;
let afterBlur = false;
let enableTimer: ReturnType<typeof setTimeout> | undefined;
const pushEnablement = (force = false) => {
const pushEnablement = (force = false, blurred = false) => {
forceEnablement ||= force;
afterBlur ||= blurred;
clearTimeout(enableTimer);
enableTimer = setTimeout(() => {
if (!ids || disposed || !document.hasFocus()) return;
const unfocused = !document.hasFocus();
if (!ids || disposed || (unfocused && !afterBlur)) return;
afterBlur = false;
const dynamic = Object.values(dynamicMenuItems()).flatMap((items) => items.map((d) => d.action));
const disabled = disabledMenuActions(new Set([...ids, ...dynamic]));
const key = disabled.join(",");
@@ -209,6 +255,8 @@ export function installMenuBridge(): () => void {
// The backend edits only submenus whose visible items changed, so switching project
// tabs does not redraw the macOS menu bar.
window.addEventListener("focus", onFocus);
const onBlur = () => pushEnablement(true, true);
window.addEventListener("blur", onBlur);
const unsubs = [
useI18n.subscribe((s, prev) => {
if (s.messages !== prev.messages) push();
@@ -237,6 +285,7 @@ export function installMenuBridge(): () => void {
clearTimeout(timer);
clearTimeout(enableTimer);
window.removeEventListener("focus", onFocus);
window.removeEventListener("blur", onBlur);
unlisten?.();
unsubs.forEach((u) => u());
};
+13 -2
Переглянути файл
@@ -130,6 +130,17 @@ export async function openPaths(
if (dir) await openProjectWithPolicy(dir);
}
/**
* `window_open_project`. When that may create a window, the trust question is asked here
* first (IntelliJ IDEA asks before the project frame opens): the new window would otherwise
* show its Welcome screen under the question. A WSL folder opens as a remote project, whose
* window asks about the distribution's folder itself.
*/
async function openProjectWindow(path: string, newWindow: boolean, files: readonly string[] = []) {
if (newWindow && !(await commands.wslResolve(path).catch(() => null))) await confirmProjectTrust(path, "local");
return call(commands.windowOpenProject(path, newWindow, [...files]));
}
/**
* Opens `path`, focusing the window that already has it. `newWindow`: always a
* new window; otherwise this window unless it already has a project or LightEdit
@@ -140,7 +151,7 @@ export async function openProjectInWindow(path: string, newWindow: boolean, file
const s = useProject.getState();
const inNew = newWindow || s.project !== null || s.lightEdit;
try {
const outcome = await call(commands.windowOpenProject(path, inNew, [...files]));
const outcome = await openProjectWindow(path, inNew, files);
if (outcome.kind === "current" && (await openHere(path))) await openInEditor(files);
} catch (e) {
openFailed(path, e);
@@ -535,7 +546,7 @@ export function windowActions(): Action[] {
const arg = c.arg as { path?: unknown; newWindow?: unknown } | null;
if (!arg || typeof arg.path !== "string" || typeof arg.newWindow !== "boolean") return;
try {
const outcome = await call(commands.windowOpenProject(arg.path, arg.newWindow, []));
const outcome = await openProjectWindow(arg.path, arg.newWindow);
if (outcome.kind === "current") await openHere(arg.path);
} catch (error) {
openFailed(arg.path, error);
+4 -1
Переглянути файл
@@ -5,6 +5,7 @@ import { call, commands, onIdeEvent, type TrustDecisions, type TrustStatus } fro
import { dirname, useProject } from "@/platform/project";
import { initializeRemoteTrustMigration, isRemoteRoot } from "@/platform/remote";
import { provideProjectTrustPrompt, type ProjectTrustScope } from "@/platform/projectTrust";
import { askOverSplash } from "@/platform/splash";
import { invokeLocal } from "@/platform/tauriCore";
import { registerOverlay, registerSettingsPage, registerWorkbenchBanner } from "@/workbench/contributions";
import { Button, Checkbox, Dialog, T } from "@/ui";
@@ -209,7 +210,7 @@ async function decide(trusted: boolean) {
function promptForTrust(status: TrustStatus, scope: ProjectTrustScope): Promise<boolean> {
usePrompt.getState().finish?.(false);
return new Promise<boolean>((resolve) =>
const answer = new Promise<boolean>((resolve) =>
usePrompt.setState({
path: status.root,
scope,
@@ -220,6 +221,8 @@ function promptForTrust(status: TrustStatus, scope: ProjectTrustScope): Promise<
},
}),
);
askOverSplash(answer);
return answer;
}
async function trustProject() {
+17
Переглянути файл
@@ -224,3 +224,20 @@ it.each([false, true])("recovers an attached member whose trust is lost (decided
await act(async () => {});
expect(decide).toHaveBeenCalledWith("/other", true, false);
});
it("asks over the splash of a window launched for an untrusted project, not over its Welcome screen", async () => {
const splash = document.createElement("div");
splash.id = "splash";
document.body.append(splash);
try {
render(<OverlayHost />);
vi.mocked(invokeLocal).mockResolvedValue({ root: "/launched", trusted: false, decided: false });
const opening = confirmProjectTrust("/launched", "local").catch(() => "cancelled");
await screen.findByRole("dialog");
expect(splash.classList.contains("splash-under-dialogs")).toBe(true);
fireEvent.click(screen.getByRole("button", { name: "Don't Open" }));
expect(await opening).toBe("cancelled");
} finally {
splash.remove();
}
});
+94
Переглянути файл
@@ -0,0 +1,94 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { act, fireEvent, render, screen } from "@testing-library/react";
import type { Sdk, Settings } from "@/platform/ipc";
const open = vi.fn();
const JDK: Sdk = {
path: "/opt/jdks/acme-17/Contents/Home",
name: "Acme 17.0.9",
version: "17.0.9",
source: "system",
home: "/opt/jdks/acme-17/Contents/Home",
extra: null,
};
vi.mock("@/platform/dialog", () => ({ open: (...args: unknown[]) => open(...args) }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
return {
...real,
isTauri: () => true,
commands: {
...real.commands,
sdkDetect: vi.fn(async () => ({ status: "ok", data: [] })),
sdkJdkAt: vi.fn(async (path: string) => ({
status: "ok",
data: path.startsWith("/opt/jdks/acme-17") ? JDK : null,
})),
settingsSet: vi.fn(async () => ({ status: "ok", data: {} })),
settingsGet: vi.fn(async () => ({})),
settingsGetGlobal: vi.fn(async () => ({})),
},
};
});
import { useProject } from "@/platform/project";
import { useContextMenuStore } from "@/ui/Menu";
import { DEFAULT_SETTINGS } from "../model/schema";
import { openProjectStructure, stagedValue, useSettingsDialog } from "../model/staging";
import { ProjectStructureDialog } from "../languages/ProjectStructurePage";
import { useSdks } from "../languages/api";
function addMenuItem(label: string) {
fireEvent.click(screen.getByRole("button", { name: "Add SDK" }));
const item = useContextMenuStore.getState().menu?.items.find((i) => "label" in i && i.label === label) as
| { run?: () => void }
| undefined;
expect(item?.run).toBeDefined();
item!.run!();
}
const added = () => stagedValue(useSettingsDialog.getState(), "global", "languages.java.addedJdks");
beforeEach(() => {
open.mockReset();
useSdks.setState({ byKind: {}, loading: {}, errors: {} });
useProject.setState({
settings: structuredClone(DEFAULT_SETTINGS) as Settings,
project: { name: "demo", root: "/project" } as never,
});
render(<ProjectStructureDialog />);
act(() => openProjectStructure("sdks"));
});
afterEach(() => {
act(() => useSettingsDialog.setState({ projectStructureOpen: false }));
useProject.setState({ project: null, settings: null });
});
describe("SDKs › Add JDK from Disk…", () => {
it("adds the picked JDK home to the list and the global settings, and removes it again", async () => {
open.mockResolvedValue("/opt/jdks/acme-17");
await act(async () => addMenuItem("Add JDK from Disk…"));
expect(open).toHaveBeenCalledWith(expect.objectContaining({ directory: true }));
expect(screen.getAllByText("Acme 17.0.9").length).toBeGreaterThan(0);
expect(added()).toEqual([JDK.path]);
fireEvent.click(screen.getByRole("button", { name: "Remove SDK" }));
expect(screen.queryByText("Acme 17.0.9")).not.toBeInTheDocument();
expect(added()).toEqual([]);
});
it("refuses a folder that is no JDK home", async () => {
open.mockResolvedValue("/tmp/not-a-jdk");
await act(async () => addMenuItem("Add JDK from Disk…"));
expect(screen.getByRole("alert")).toHaveTextContent("The selected directory is not a valid home for JDK");
expect(added() ?? []).toEqual([]);
});
it("keeps detected SDKs from being removed", async () => {
await act(async () => useSdks.setState({ byKind: { jdk: [JDK] } }));
fireEvent.click(screen.getByRole("option", { name: /Acme 17\.0\.9/ }));
expect(screen.getByRole("button", { name: "Remove SDK" })).toBeDisabled();
});
});
+1 -1
Переглянути файл
@@ -53,7 +53,7 @@ import {
} from "./model";
import { groupIcon, groupPath, groupRank } from "./groups";
import { KeymapNameDialog } from "./KeymapDialogs";
import { parseIdeaKeymap } from "./ideaKeymapImport";
import { parseIdeaKeymap } from "@/platform/ideaKeymap";
import { RecordShortcutDialog } from "./RecordShortcutDialog";
import { StrokeRecorder } from "./StrokeRecorder";
import styles from "./Keymap.module.css";
+13 -39
Переглянути файл
@@ -5,23 +5,19 @@
*/
import type { Action } from "@/platform/actions";
import { evaluateWhen, type ContextKeys } from "@/platform/context";
import { defaultPreset, normalizeBinding, PRESET_TITLES, PRESETS, useKeymap, type Keymap } from "@/platform/keymap";
import {
customKeymapId,
defaultPreset,
normalizeBinding,
presetBindings,
PRESET_TITLES,
PRESETS,
withBindings,
type Keymap,
type KeymapDraft,
} from "@/platform/keymap";
export interface KeymapDraft {
preset: string;
overrides: Keymap;
}
/**
* The defaults of `id`: the preset's, or for an action the preset leaves out,
* the shortcut its plugin declares (`keymaps`). Removing or changing one is an
* override like any other.
*/
export function presetBindings(preset: string, id: string): string[] {
const own = PRESETS[preset];
const keys = own && id in own ? own[id] : useKeymap.getState().extensions?.[id];
return (keys ?? []).map(normalizeBinding);
}
export { presetBindings, withBindings, type KeymapDraft };
export function resolveBindings(draft: KeymapDraft, id: string): string[] {
return draft.overrides[id]?.map(normalizeBinding) ?? presetBindings(draft.preset, id);
@@ -41,17 +37,6 @@ export function isModified(draft: KeymapDraft, id: string): boolean {
return id in draft.overrides;
}
const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
/** Sets the full binding list of `id`; drops the override when it equals the preset. */
export function withBindings(draft: KeymapDraft, id: string, bindings: readonly string[]): Keymap {
const list = [...new Set(bindings.map(normalizeBinding))];
const overrides = { ...draft.overrides };
if (sameList(list, presetBindings(draft.preset, id))) delete overrides[id];
else overrides[id] = list;
return overrides;
}
export function addBinding(draft: KeymapDraft, id: string, binding: string): Keymap {
return withBindings(draft, id, [...resolveBindings(draft, id), binding]);
}
@@ -235,24 +220,13 @@ export function validateKeymapName(name: string, customs: CustomKeymaps, ownId?:
return clash ? `Keymap '${n}' already exists` : null;
}
function newKeymapId(name: string, customs: CustomKeymaps): string {
const slug =
name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "keymap";
let id = `custom.${slug}`;
for (let i = 2; customs[id] || PRESETS[id]; i++) id = `custom.${slug}-${i}`;
return id;
}
/** Copies the selected keymap (its effective overrides) under `name`; returns the new id. */
export function duplicateKeymap(
draft: KeymapDraft,
customs: CustomKeymaps,
name: string,
): { id: string; customs: CustomKeymaps } {
const id = newKeymapId(name, customs);
const id = customKeymapId(name, customs);
return {
id,
customs: { ...customs, [id]: { name: name.trim(), parent: draft.preset, overrides: { ...draft.overrides } } },
+60 -8
Переглянути файл
@@ -28,7 +28,7 @@ import { call, commands, isTauri, nextRequestId, type FileEntry } from "@/platfo
import { mergeLibraryGroups } from "@/platform/libraries";
import type { BuildModel, LibraryGroup, WebArtifact } from "@/bindings";
import { relativePath, useProject } from "@/platform/project";
import { PageContext, useSettingsFormFor } from "../components/context";
import { PageContext, useSetting, useSettingsFormFor } from "../components/context";
import {
applySettings,
closeProjectStructure,
@@ -61,7 +61,7 @@ import {
} from "@/platform/languageSettings";
import { initProjectRoots, useDetectedRoots } from "@/platform/projectRoots";
import { Row, Section } from "../components/Form";
import { detectSdks, useSdks, type SdkKind } from "./api";
import { detectSdks, forgetSdk, rememberSdk, useSdks, type SdkKind } from "./api";
import { choosePath } from "@/platform/choosePath";
import { DownloadJdkDialog } from "./DownloadJdkDialog";
import { SdkField, tildify, useDetected, useJdtlsJdk, useProjectSetting } from "./components";
@@ -1790,8 +1790,31 @@ function SdksSection() {
const [downloading, setDownloading] = useState(false);
const [selectedKey, setSelectedKey] = useState<string>("");
const [projectJdk, setProjectJdk] = useProjectSetting<string>("languages.java.jdk");
const [addedJdks, setAddedJdks] = useSetting<string[] | undefined>("languages.java.addedJdks", "global");
const [addError, setAddError] = useState<string | null>(null);
useDetected("jdk");
const addJdkFromDisk = async () => {
setAddError(null);
const picked = await choosePath({ directory: true, title: tx("Select Home Directory for JDK") });
if (!picked) return;
const sdk = await call(commands.sdkJdkAt(picked)).catch(() => null);
if (!sdk) {
setAddError(tx`The selected directory is not a valid home for JDK: ${tildify(picked)}`);
return;
}
const added = addedJdks ?? [];
if (!added.includes(sdk.path)) setAddedJdks([...added, sdk.path]);
rememberSdk("jdk", { ...sdk, source: "added" });
setSelectedKey(`jdk:${sdk.path}`);
};
const removeAddedJdk = (path: string) => {
setAddedJdks((addedJdks ?? []).filter((p) => p !== path));
forgetSdk("jdk", path);
setSelectedKey("");
};
useEffect(() => {
for (const { kind } of SDK_KINDS) {
void detectSdks(kind);
@@ -1805,8 +1828,15 @@ function SdksSection() {
};
const rows = useMemo(() => {
const out: Array<{ key: string; kind: SdkKind; kindLabel: string; name: string; version: string; path: string }> =
[];
const out: Array<{
key: string;
kind: SdkKind;
kindLabel: string;
name: string;
version: string;
path: string;
added: boolean;
}> = [];
for (const { kind, label } of SDK_KINDS) {
for (const sdk of byKind[kind] ?? []) {
out.push({
@@ -1816,11 +1846,12 @@ function SdksSection() {
name: sdk.name,
version: sdk.version ?? "",
path: sdk.path,
added: kind === "jdk" && (sdk.source === "added" || (addedJdks ?? []).includes(sdk.path)),
});
}
}
return out;
}, [byKind]);
}, [byKind, addedJdks]);
const activeSdk = rows.find((r) => r.key === selectedKey) ?? rows[0];
@@ -1829,12 +1860,33 @@ function SdksSection() {
<div className={styles.splitLayout}>
<div className={styles.sideList}>
<div className={styles.tableToolbar}>
<Button size="small" variant="ghost" icon="plus" onClick={() => setDownloading(true)}>
<T>Download JDK…</T>
</Button>
<IconButton
icon="plus"
size="small"
title="Add SDK"
onClick={(e) => {
const r = e.currentTarget.getBoundingClientRect();
showContextMenu({ x: r.left, y: r.bottom + 2 }, [
{ label: tx("Download JDK…"), icon: "download", run: () => setDownloading(true) },
{ label: tx("Add JDK from Disk…"), icon: "folder-open", run: () => void addJdkFromDisk() },
]);
}}
/>
<IconButton
icon="minus"
size="small"
title="Remove SDK"
disabled={!activeSdk?.added}
onClick={() => activeSdk && removeAddedJdk(activeSdk.path)}
/>
<span className={styles.spacer} />
<IconButton icon="refresh" size="small" title="Detect again" onClick={refreshAll} />
</div>
{addError && (
<div className={styles.error} role="alert">
{addError}
</div>
)}
<div className={styles.sideItems} role="listbox" aria-label={tx("SDKs")}>
{rows.length === 0 && (
<div className={styles.empty}>
+5
Переглянути файл
@@ -63,6 +63,11 @@ export function detectSdks(kind: SdkKind, force = false): Promise<Sdk[]> {
return p;
}
/** Drops an SDK (e.g. a JDK added by hand, then removed) from the cached list. */
export function forgetSdk(kind: SdkKind, path: string) {
useSdks.setState((s) => ({ byKind: { ...s.byKind, [kind]: (s.byKind[kind] ?? []).filter((x) => x.path !== path) } }));
}
/** Adds an SDK (e.g. a just-created virtualenv) to the cached list. */
export function rememberSdk(kind: SdkKind, sdk: Sdk) {
const remember = () =>
+16 -30
Переглянути файл
@@ -1,8 +1,9 @@
/**
* CodeMirror setup for the VCS viewers (diff, merge, local history): token
* based theme + syntax colours and lazy language loading by file name.
* based theme + syntax colours and lazy language loading through the editor's
* language pipeline, so colours match the editor.
*/
import { HighlightStyle, LanguageDescription, syntaxHighlighting, type LanguageSupport } from "@codemirror/language";
import { syntaxHighlighting, type LanguageSupport } from "@codemirror/language";
import {
Compartment,
EditorState,
@@ -32,8 +33,9 @@ import {
import { getChunks, mergeViewSiblings, type Chunk } from "@codemirror/merge";
import { defaultKeymap } from "@codemirror/commands";
import { search, searchKeymap } from "@codemirror/search";
import { tags as t } from "@lezer/highlight";
import { scrollbarMarks, type ScrollbarMark } from "@/editor/api";
import { openideaHighlightStyle } from "@/editor/core/cm/highlight";
import { findLanguageDescription, loadSupport, uiModeForPath } from "@/editor/core/cm/languages";
import { findExtension } from "@/editor/core/cm/find";
import { overviewLane, overviewLaneIn } from "@/editor/core/cm/lanes";
import { LINE_INSET } from "@/editor/core/cm/lineInset";
@@ -294,26 +296,6 @@ export const diffWords: Extension = [
EditorView.editorAttributes.of({ class: "cm-diffWords" }),
];
export const viewerHighlight = HighlightStyle.define([
{
tag: [t.keyword, t.modifier, t.controlKeyword, t.operatorKeyword, t.definitionKeyword],
color: "var(--syn-keyword)",
},
{ tag: [t.string, t.special(t.string), t.regexp, t.character], color: "var(--syn-string)" },
{ tag: [t.typeName, t.className, t.namespace, t.tagName], color: "var(--syn-type)" },
{ tag: [t.function(t.variableName), t.function(t.propertyName)], color: "var(--syn-function)" },
{ tag: [t.comment, t.lineComment, t.blockComment, t.docComment], color: "var(--syn-comment)", fontStyle: "italic" },
{ tag: [t.annotation, t.meta, t.attributeName], color: "var(--syn-annotation)" },
{ tag: [t.number, t.bool, t.null, t.atom], color: "var(--syn-number)" },
{ tag: [t.constant(t.variableName), t.standard(t.variableName)], color: "var(--syn-constant)" },
{ tag: [t.punctuation, t.bracket, t.operator], color: "var(--syn-punct)" },
{ tag: [t.propertyName], color: "var(--syn-property)" },
{ tag: [t.variableName], color: "var(--syn-variable)" },
{ tag: t.invalid, color: "var(--syn-invalid)" },
{ tag: t.heading, fontWeight: "var(--fw-code-bold, 700)", color: "var(--fg-strong)" },
{ tag: t.link, color: "var(--link)", textDecoration: "underline" },
]);
export const viewerTheme = EditorView.theme(
{
...overviewStyles,
@@ -530,7 +512,7 @@ export function viewerBase(opts: {
opts.findBar
? [findExtension(), keymap.of(defaultKeymap)]
: [search({ top: true }), keymap.of([...searchKeymap, ...defaultKeymap])],
syntaxHighlighting(viewerHighlight),
syntaxHighlighting(openideaHighlightStyle),
viewerTheme,
changedLines,
EditorState.readOnly.of(opts.readOnly),
@@ -540,18 +522,22 @@ export function viewerBase(opts: {
];
}
let languagesPromise: Promise<readonly LanguageDescription[]> | null = null;
const cache = new Map<string, Promise<LanguageSupport | null>>();
/** Loads the language for `fileName` (by extension / name), or null. */
/**
* Loads the language for `fileName` through the editor's pipeline
* (`findLanguageDescription` + `loadSupport`): the same modes, tag patches and
* `data-language` attribute as the editor, so colours match. Unknown
* extensions resolve like the editor's (null once the backend languages are
* loaded, file-name match before that).
*/
export function languageFor(fileName: string): Promise<LanguageSupport | null> {
const name = fileName.slice(fileName.lastIndexOf("/") + 1);
const hit = cache.get(name);
if (hit) return hit;
languagesPromise ??= import("@codemirror/language-data").then((m) => m.languages);
const p = languagesPromise
.then((langs) => LanguageDescription.matchFilename(langs, name))
.then((desc) => (desc ? desc.load() : null))
const p = Promise.resolve(uiModeForPath(fileName))
.then((uiMode) => findLanguageDescription(uiMode ?? null, fileName))
.then((desc) => (desc ? loadSupport(desc) : null))
.catch(() => null);
cache.set(name, p);
return p;
+5 -1
Переглянути файл
@@ -1,6 +1,6 @@
import { describe, expect, it } from "vitest";
import { normalizeBinding } from "@/platform/keymap";
import { fromSwingStroke, parseIdeaKeymap } from "../keymap/ideaKeymapImport";
import { fromSwingStroke, parseIdeaKeymap } from "./ideaKeymap";
describe("IntelliJ IDEA keymap import", () => {
it("converts Swing keystrokes", () => {
@@ -8,6 +8,10 @@ describe("IntelliJ IDEA keymap import", () => {
expect(fromSwingStroke("ctrl pressed OPEN_BRACKET")).toBe("Ctrl+[");
expect(fromSwingStroke("F12")).toBe("F12");
expect(fromSwingStroke("alt BACK_SPACE")).toBe("Alt+Backspace");
// As IDEA saves a user's keymap.
expect(fromSwingStroke("ctrl right")).toBe("Ctrl+Right");
expect(fromSwingStroke("shift ctrl alt s")).toBe("Shift+Ctrl+Alt+S");
expect(fromSwingStroke("meta back_slash")).toBe("Meta+\\");
expect(fromSwingStroke("meta NUMPAD5")).toBeNull();
expect(fromSwingStroke("hyper A")).toBeNull();
});
+28 -4
Переглянути файл
@@ -4,8 +4,16 @@
* parent; each listed action's shortcuts replace the parent's.
*/
import { IDEA_ACTIONS } from "@/platform/ideaActions";
import { defaultPreset, isValidBinding, normalizeBinding, type Keymap } from "@/platform/keymap";
import { withBindings } from "./model";
import type { CustomKeymap } from "@/bindings";
import {
customKeymapId,
defaultPreset,
isValidBinding,
normalizeBinding,
PRESET_TITLES,
withBindings,
type Keymap,
} from "@/platform/keymap";
export interface ImportedIdeaKeymap {
name: string;
@@ -67,13 +75,16 @@ const SWING_KEYS: Record<string, string> = {
const SWING_MODS: Record<string, string> = { shift: "Shift", ctrl: "Ctrl", control: "Ctrl", alt: "Alt", meta: "Meta" };
/** `"shift meta O"` / `"ctrl pressed OPEN_BRACKET"` → `"Meta+Shift+O"`, or null when not expressible. */
/**
* `"shift meta O"` / `"ctrl pressed OPEN_BRACKET"` → `"Meta+Shift+O"`, or null when not expressible.
* Bundled keymaps name keys in upper case; the keymaps IDEA saves for the user are all lower case (`"ctrl right"`).
*/
export function fromSwingStroke(stroke: string): string | null {
const words = stroke
.trim()
.split(/\s+/)
.filter((w) => !/^(pressed|released|typed)$/i.test(w));
const key = words.pop();
const key = words.pop()?.toUpperCase();
if (!key || words.some((w) => !SWING_MODS[w.toLowerCase()])) return null;
const name = /^([A-Z0-9]|F\d{1,2})$/.test(key) ? key : SWING_KEYS[key];
return name ? [...words.map((w) => SWING_MODS[w.toLowerCase()]), name].join("+") : null;
@@ -134,3 +145,16 @@ export function parseIdeaKeymap(xml: string): ImportedIdeaKeymap {
skippedShortcuts,
};
}
/**
* Adds a parsed keymap to the user keymaps under its own name, replacing an
* earlier import of the same name (a name a bundled keymap has gets a suffix).
*/
export function addIdeaKeymap(
customs: Record<string, CustomKeymap>,
parsed: ImportedIdeaKeymap,
): { id: string; customs: Record<string, CustomKeymap> } {
const name = Object.values(PRESET_TITLES).includes(parsed.name) ? `${parsed.name} (JetBrains)` : parsed.name;
const id = Object.keys(customs).find((k) => customs[k]?.name === name) ?? customKeymapId(name, customs);
return { id, customs: { ...customs, [id]: { name, parent: parsed.parent, overrides: parsed.overrides } } };
}
+40
Переглянути файл
@@ -730,3 +730,43 @@ export function installKeyboardDispatcher(
target.removeEventListener("blur", onBlur);
};
}
/** A keymap being edited: a bundled preset and the overrides on top of it. */
export interface KeymapDraft {
preset: string;
overrides: Keymap;
}
/**
* The defaults of `id`: the preset's, or for an action the preset leaves out,
* the shortcut its plugin declares (`keymaps`). Removing or changing one is an
* override like any other.
*/
export function presetBindings(preset: string, id: string): string[] {
const own = PRESETS[preset];
const keys = own && id in own ? own[id] : useKeymap.getState().extensions?.[id];
return (keys ?? []).map(normalizeBinding);
}
const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
/** Sets the full binding list of `id`; drops the override when it equals the preset. */
export function withBindings(draft: KeymapDraft, id: string, bindings: readonly string[]): Keymap {
const list = [...new Set(bindings.map(normalizeBinding))];
const overrides = { ...draft.overrides };
if (sameList(list, presetBindings(draft.preset, id))) delete overrides[id];
else overrides[id] = list;
return overrides;
}
/** A free id for a user keymap called `name`. */
export function customKeymapId(name: string, customs: Record<string, unknown>): string {
const slug =
name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "keymap";
let id = `custom.${slug}`;
for (let i = 2; customs[id] || PRESETS[id]; i++) id = `custom.${slug}-${i}`;
return id;
}
+11 -1
Переглянути файл
@@ -465,6 +465,8 @@
"These settings will be imported:": "These settings will be imported:",
"Not imported:": "Not imported:",
"Current color scheme": "Current color scheme",
"Current keymap": "Current keymap",
"Code Style options other than Tabs and Indents": "Code Style options other than Tabs and Indents",
"No settings OpenIDEA can import were found": "No settings OpenIDEA can import were found",
"Overwrite existing branch": "Overwrite existing branch",
"Unset upstream branch": "Unset upstream branch",
@@ -2002,5 +2004,13 @@
"Target": "Target",
"Foreign Keys": "Foreign Keys",
"Indexes": "Indexes",
"Columns": "Columns"
"Columns": "Columns",
"Add JDK from Disk…": "Add JDK from Disk…",
"Select Home Directory for JDK": "Select Home Directory for JDK",
"The selected directory is not a valid home for JDK: {path}": "The selected directory is not a valid home for JDK: {path}",
"Add SDK": "Add SDK",
"Remove SDK": "Remove SDK",
"{rel} is added to your request": "{rel} is added to your request",
"IDE Context Enabled: the current file and selection are added to your request": "IDE Context Enabled: the current file and selection are added to your request",
"IDE Context Disabled: the current file and selection are not added to your request": "IDE Context Disabled: the current file and selection are not added to your request"
}
+11 -1
Переглянути файл
@@ -3512,6 +3512,8 @@
"These settings will be imported:": "将导入以下设置:",
"Not imported:": "不导入:",
"Current color scheme": "当前配色方案",
"Current keymap": "当前按键映射",
"Code Style options other than Tabs and Indents": "制表符和缩进以外的代码样式选项",
"No settings OpenIDEA can import were found": "没有找到 OpenIDEA 可以导入的设置",
"Rename Project": "重命名项目",
"Rename Project…": "重命名项目…",
@@ -8390,5 +8392,13 @@
"Only in target": "仅在目标中",
"Different": "不同",
"Foreign Keys": "外键",
"Indexes": "索引"
"Indexes": "索引",
"Add JDK from Disk…": "从磁盘添加 JDK…",
"Select Home Directory for JDK": "选择 JDK 主目录",
"The selected directory is not a valid home for JDK: {path}": "所选目录不是有效的 JDK 主目录:{path}",
"Add SDK": "添加 SDK",
"Remove SDK": "移除 SDK",
"{rel} is added to your request": "{rel} 会添加到你的请求中",
"IDE Context Enabled: the current file and selection are added to your request": "IDE 上下文已启用:当前文件和所选内容会添加到你的请求中",
"IDE Context Disabled: the current file and selection are not added to your request": "IDE 上下文已禁用:当前文件和所选内容不会添加到你的请求中"
}
+39
Переглянути файл
@@ -0,0 +1,39 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
beforeEach(() => {
vi.useFakeTimers({ toFake: ["setTimeout", "requestAnimationFrame"] });
vi.resetModules();
document.body.innerHTML = '<div id="splash" class="splash"></div>';
});
afterEach(() => vi.useRealTimers());
const splash = () => document.getElementById("splash");
it("gives up on a slow launch after its time limit", async () => {
const { holdSplash, hideSplash } = await import("./splash");
holdSplash(new Promise(() => {}));
hideSplash();
await vi.advanceTimersByTimeAsync(5000);
expect(splash()).toBeNull();
});
it("stays up, under dialogs, until a question asked while the window opens is answered", async () => {
const { askOverSplash, holdSplash, hideSplash } = await import("./splash");
let answer!: (open: boolean) => void;
const question = new Promise<boolean>((resolve) => (answer = resolve));
holdSplash(question);
hideSplash();
askOverSplash(question);
expect(splash()?.classList.contains("splash-under-dialogs")).toBe(true);
await vi.advanceTimersByTimeAsync(60_000);
expect(splash()).not.toBeNull();
answer(false);
await vi.advanceTimersByTimeAsync(1000);
expect(splash()).toBeNull();
});
it("leaves a page without a splash alone", async () => {
document.body.innerHTML = "";
const { askOverSplash } = await import("./splash");
expect(() => askOverSplash(Promise.resolve(true))).not.toThrow();
});
+19 -3
Переглянути файл
@@ -20,6 +20,21 @@ function completeBar(el: HTMLElement): boolean {
return true;
}
const questions = new Set<Promise<unknown>>();
/**
* Keeps the splash up, past its time limit, until the user answers `question` in a dialog
* shown over it: a window launched for an untrusted project (`openidea <path>`) asks
* before anything of the window shows, never over its Welcome screen.
*/
export function askOverSplash(question: Promise<unknown>): void {
const el = document.getElementById("splash");
if (!el || el.classList.contains("splash-out")) return;
el.classList.add("splash-under-dialogs");
const answered: Promise<unknown> = question.catch(() => {}).finally(() => questions.delete(answered));
questions.add(answered);
}
/** Keeps the splash up until `work` settles. Call before `hideSplash()`. */
export function holdSplash(work: Promise<unknown>): void {
holds.push(work.catch(() => {}));
@@ -30,7 +45,8 @@ export function hideSplash(): void {
const el = document.getElementById("splash");
if (!el) return;
const timeout = new Promise((resolve) => setTimeout(resolve, MAX_WAIT_MS));
void Promise.race([Promise.all(holds), timeout]).then(() =>
void Promise.race([Promise.all(holds), timeout]).then(async () => {
while (questions.size) await Promise.all(questions);
// Two frames: let React commit the state the holds produced before uncovering it.
requestAnimationFrame(() =>
requestAnimationFrame(() => {
@@ -47,6 +63,6 @@ export function hideSplash(): void {
completeBar(el) ? FILL_MS : 0,
);
}),
),
);
);
});
}