The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(workbench): Open files from Finder in the single-file window (#152)
l0ng-ai1d383e608c25
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 87cec86a4..9005f1bae 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -13,7 +13,10 @@ mod state;mod theme_frame;mod windows;+use parking_lot::Mutex;use state::AppState;+use std::path::PathBuf;+use std::sync::Arc;use tauri::{Emitter, Manager};use windows::WindowsState;@@ -74,6 +77,9 @@ pub fn run() {#[cfg(debug_assertions)]let app = app.plugin(tauri_plugin_mcp_bridge::Builder::new().bind_address("127.0.0.1").build());+ // Paths macOS asked to open (Finder's Open With, the Dock) before setup ran: the first window takes them.+ let early_opens: Arc<Mutex<Option<Vec<PathBuf>>>> = Arc::default();+ let setup_opens = early_opens.clone();app.invoke_handler(builder.invoke_handler()).setup(move |app| {builder.mount_events(app);@@ -89,6 +95,9 @@ pub fn run() {app.manage(state);app.manage(windows);app.manage(menu_state);+ if let Some(paths) = setup_opens.lock().take() {+ windows::open_paths_at_launch(app.handle(), paths);+ }app.on_menu_event(on_menu_event);windows::create_main_window(app.handle())?;Ok(())@@ -115,7 +124,18 @@ pub fn run() {}).build(context).expect("error while running OpenIDEA")- .run(|app, event| {+ .run(move |app, event| {+ #[cfg(target_os = "macos")]+ if let tauri::RunEvent::Opened { urls } = &event {+ let paths = windows::opened_paths(urls);+ if app.try_state::<WindowsState>().is_some() {+ windows::open_paths(app, paths);+ } else {+ early_opens.lock().get_or_insert_default().extend(paths);+ }+ }+ #[cfg(not(target_os = "macos"))]+ let _ = &early_opens;// Quit after installing an update (`app_install_update`): relaunch.if let tauri::RunEvent::Exit = event&& app.try_state::<WindowsState>().is_some_and(|w| w.restart_requested())diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rsindex 06f1d75ef..a56188415 100644--- a/src-tauri/src/windows.rs+++ b/src-tauri/src/windows.rs@@ -77,6 +77,17 @@ impl WindowsState {self.launches.lock().remove(label)}+ /// Adds `files` to `label`'s pending launch, so files sent before its frontend took the last batch aren't lost.+ pub fn add_files(&self, label: &str, files: Vec<PathBuf>) {+ let mut launches = self.launches.lock();+ let launch = launches.entry(label.to_owned()).or_default();+ launch.files.extend(files.into_iter().map(Into::into));+ }++ fn pending(&self, label: &str) -> Option<Launch> {+ self.launches.lock().get(label).cloned()+ }+pub fn focused(&self, label: &str) {*self.last_focused.lock() = Some(label.to_owned());}@@ -206,8 +217,7 @@ pub fn find_light_window(app: &AppHandle) -> Option<WebviewWindow> {/// Hands `files` to the already loaded `window` (its frontend takes them on [`LAUNCH_EVENT`]) and focuses it.fn send_files(app: &AppHandle, window: &WebviewWindow, files: Vec<PathBuf>) {- let launch = Launch { files: files.into_iter().map(Into::into).collect(), ..Default::default() };- app.state::<WindowsState>().set_launch(window.label(), launch);+ app.state::<WindowsState>().add_files(window.label(), files);let _ = app.emit_to(window.label(), LAUNCH_EVENT, ());focus(window);}@@ -422,46 +432,200 @@ pub fn open_remote_window(app: &AppHandle, ssh_config: &str, path: &str, new_winOk(OpenOutcome::Opened { label: window.label().to_owned() })}-/// Opens `path` from the command line / a second instance: a folder focuses the-/// window that has it, a file joins the LightEdit window; else a window without-/// a project is reused, else a new one is made.-pub fn open_path(app: &AppHandle, path: &Path) {- let path = match dunce::canonicalize(path) {- Ok(p) => p,- Err(e) => {- tracing::warn!("cannot open {}: {e}", path.display());- return;+/// What a window holds, for routing paths opened from outside (command line, Finder).+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum Holds {+ /// Nothing yet (Welcome screen): free to take a launch.+ Nothing,+ LightEdit,+ Project(PathBuf),+ /// A remote project.+ Other,+}++/// What window `label` holds: its open project, else what its pending launch is about to open.+fn holds(app: &AppHandle, label: &str) -> Holds {+ let state = app.try_state::<AppState>();+ if let Some(project) = state.as_ref().and_then(|s| s.project(label).ok()) {+ return if project.light { Holds::LightEdit } else { Holds::Project(project.root.clone()) };+ }+ if state.is_some_and(|s| s.remote_dev.get(label).is_some()) {+ return Holds::Other;+ }+ pending_holds(app.state::<WindowsState>().pending(label).as_ref())+}++fn pending_holds(launch: Option<&Launch>) -> Holds {+ match launch {+ Some(Launch { project: Some(root), .. }) => Holds::Project(root.to_path_buf()),+ Some(Launch { remote: Some(_), .. }) => Holds::Other,+ Some(l) if !l.files.is_empty() => Holds::LightEdit,+ _ => Holds::Nothing,+ }+}++/// One step of opening paths from outside; see [`plan_open`].+#[derive(Debug, PartialEq, Eq)]+pub enum OpenStep {+ /// The window already has the folder open.+ Focus(String),+ /// Files open in this window: in its project, or join its LightEdit session.+ Files(String, Vec<PathBuf>),+ /// A free window opens this.+ Launch(String, Launch),+ /// A new window opens the project folder or (without one) the files in LightEdit.+ New(Option<PathBuf>, Vec<PathBuf>),+}++/// Where a file inside a project goes: a window with it open, or the step opening it.+enum ProjectTarget {+ Window(String),+ Step(usize),+}++/// Routes canonical `paths` (with whether each is a folder) over `windows` (the preferred+/// free one first). A folder focuses the window that has it open, else takes a free window,+/// else a new one. A file inside a local project being opened (the deepest root if nested)+/// opens in that project's window; the others all join the LightEdit window, else a free+/// window or a new one switches to LightEdit for them.+pub fn plan_open(paths: Vec<(PathBuf, bool)>, windows: &[(String, Holds)]) -> Vec<OpenStep> {+ let mut free = windows.iter().filter(|(_, h)| *h == Holds::Nothing).map(|(l, _)| l.clone());+ let (mut dirs, mut files) = (Vec::new(), Vec::new());+ for (path, is_dir) in paths {+ let list = if is_dir { &mut dirs } else { &mut files };+ if !list.contains(&path) {+ list.push(path);}- };- let is_dir = path.is_dir();- if is_dir && let Some(w) = find_project_window(app, &path) {- focus(&w);- return;}- if !is_dir && let Some(w) = find_light_window(app) {- send_files(app, &w, vec![path]);- return;- }- let free = target_window(app)- .filter(|w| !has_project(app, w.label()))- .filter(|w| !is_settings_window(w.label()))- .or_else(|| {- app.webview_windows().into_values().find(|w| !is_settings_window(w.label()) && !has_project(app, w.label()))+ let mut steps = Vec::new();+ let mut roots: Vec<(PathBuf, ProjectTarget)> = windows+ .iter()+ .filter_map(|(label, h)| match h {+ Holds::Project(root) => Some((root.clone(), ProjectTarget::Window(label.clone()))),+ _ => None,+ })+ .collect();+ for dir in dirs {+ if let Some((label, _)) = windows.iter().find(|(_, h)| matches!(h, Holds::Project(root) if *root == dir)) {+ steps.push(OpenStep::Focus(label.clone()));+ continue;+ }+ roots.push((dir.clone(), ProjectTarget::Step(steps.len())));+ steps.push(match free.next() {+ Some(label) => OpenStep::Launch(label, path_launch_of(Some(dir), Vec::new())),+ None => OpenStep::New(Some(dir), Vec::new()),});- let launch = path_launch(path);- match free {- Some(w) => {- app.state::<WindowsState>().set_launch(w.label(), launch);- let _ = app.emit_to(w.label(), LAUNCH_EVENT, ());- focus(&w);+ }+ let mut in_windows: Vec<(String, Vec<PathBuf>)> = Vec::new();+ let mut loose = Vec::new();+ for file in files {+ let deepest =+ roots.iter().filter(|(root, _)| file.starts_with(root)).max_by_key(|(root, _)| root.components().count());+ match deepest.map(|(_, target)| target) {+ Some(ProjectTarget::Window(label)) => match in_windows.iter_mut().find(|(l, _)| l == label) {+ Some((_, list)) => list.push(file),+ None => in_windows.push((label.clone(), vec![file])),+ },+ Some(ProjectTarget::Step(i)) => match &mut steps[*i] {+ OpenStep::Launch(_, launch) => launch.files.push(file.into()),+ OpenStep::New(_, list) => list.push(file),+ OpenStep::Focus(_) | OpenStep::Files(..) => unreachable!("folders opened by the plan launch or open"),+ },+ None => loose.push(file),}- None => {- let files = launch.files.into_iter().map(ide_core::IpcPath::into_path_buf).collect();- spawn_window_with(app, launch.project.map(ide_core::IpcPath::into_path_buf), files)+ }+ steps.extend(in_windows.into_iter().map(|(label, files)| OpenStep::Files(label, files)));+ if !loose.is_empty() {+ let light = windows.iter().find(|(_, h)| *h == Holds::LightEdit).map(|(l, _)| l.clone());+ steps.push(match (light, free.next()) {+ (Some(label), _) => OpenStep::Files(label, loose),+ (None, Some(label)) => OpenStep::Launch(label, path_launch_of(None, loose)),+ (None, None) => OpenStep::New(None, loose),+ });+ }+ steps+}++fn path_launch_of(project: Option<PathBuf>, files: Vec<PathBuf>) -> Launch {+ Launch {+ project: project.map(Into::into),+ files: files.into_iter().map(Into::into).collect(),+ ..Default::default()+ }+}++/// Canonical existing `paths` with whether each is a folder; the others are logged and dropped.+fn resolve(paths: Vec<PathBuf>) -> Vec<(PathBuf, bool)> {+ paths+ .into_iter()+ .filter_map(|path| match dunce::canonicalize(&path) {+ Ok(p) => {+ let is_dir = p.is_dir();+ Some((p, is_dir))+ }+ Err(e) => {+ tracing::warn!("cannot open {}: {e}", path.display());+ None+ }+ })+ .collect()+}++/// Opens `path` from the command line / a second instance; see [`open_paths`].+pub fn open_path(app: &AppHandle, path: &Path) {+ open_paths(app, vec![path.to_path_buf()]);+}++/// Opens paths from outside the app (a second instance, Finder's Open With, the Dock):+/// see [`plan_open`]; the focused window is the preferred free one.+pub fn open_paths(app: &AppHandle, paths: Vec<PathBuf>) {+ let preferred = target_window(app).map(|w| w.label().to_owned());+ let mut labels = project_window_labels(app);+ if let Some(i) = preferred.and_then(|p| labels.iter().position(|l| *l == p)) {+ let first = labels.remove(i);+ labels.insert(0, first);+ }+ let windows: Vec<(String, Holds)> = labels.into_iter().map(|l| (l.clone(), holds(app, &l))).collect();+ run_open(app, plan_open(resolve(paths), &windows));+}++/// [`open_paths`] while the app is starting, before the `main` window exists: it takes them as its launch.+pub fn open_paths_at_launch(app: &AppHandle, paths: Vec<PathBuf>) {+ let main = pending_holds(app.state::<WindowsState>().pending(MAIN).as_ref());+ run_open(app, plan_open(resolve(paths), &[(MAIN.to_owned(), main)]));+}++fn run_open(app: &AppHandle, steps: Vec<OpenStep>) {+ let windows = app.state::<WindowsState>();+ for step in steps {+ match step {+ OpenStep::Focus(label) => {+ if let Some(w) = app.get_webview_window(&label) {+ focus(&w);+ }+ }+ OpenStep::Files(label, files) => match app.get_webview_window(&label) {+ Some(w) => send_files(app, &w, files),+ None => windows.add_files(&label, files),+ },+ OpenStep::Launch(label, launch) => {+ windows.set_launch(&label, launch);+ if let Some(w) = app.get_webview_window(&label) {+ let _ = app.emit_to(&label, LAUNCH_EVENT, ());+ focus(&w);+ }+ }+ OpenStep::New(project, files) => spawn_window_with(app, project, files),}}}+/// Local files and folders of the URLs macOS asks the app to open (Finder's Open With, the Dock).+#[cfg(target_os = "macos")]+pub fn opened_paths(urls: &[tauri::Url]) -> Vec<PathBuf> {+ urls.iter().filter_map(|u| u.to_file_path().ok()).collect()+}+/// What a window opens for a command-line path: a folder as its project, a file in LightEdit.pub fn path_launch(path: PathBuf) -> Launch {if path.is_dir() {@@ -650,6 +814,124 @@ mod tests {assert_eq!((launch.project, launch.files), (None, vec![file.into()]));}+ fn p(s: &str) -> PathBuf {+ PathBuf::from(s)+ }++ fn w(label: &str, holds: Holds) -> (String, Holds) {+ (label.to_owned(), holds)+ }++ #[test]+ fn opening_at_launch_gives_the_first_window_files_or_folder() {+ let main = [w("main", Holds::Nothing)];+ let files = plan_open(vec![(p("/x/a.txt"), false), (p("/y/b.rs"), false)], &main);+ assert_eq!(files, [OpenStep::Launch("main".into(), path_launch_of(None, vec![p("/x/a.txt"), p("/y/b.rs")]))]);+ let dir = plan_open(vec![(p("/proj"), true)], &main);+ assert_eq!(dir, [OpenStep::Launch("main".into(), path_launch_of(Some(p("/proj")), Vec::new()))]);+ // Folder and files: the folder takes the first window, the files a new LightEdit one.+ let both = plan_open(vec![(p("/x/a.txt"), false), (p("/proj"), true)], &main);+ assert_eq!(+ both,+ [+ OpenStep::Launch("main".into(), path_launch_of(Some(p("/proj")), Vec::new())),+ OpenStep::New(None, vec![p("/x/a.txt")]),+ ]+ );+ }++ #[test]+ fn files_opened_at_launch_join_files_from_the_command_line() {+ let cli = path_launch_of(None, vec![p("/x/a.txt")]);+ let main = [w("main", pending_holds(Some(&cli)))];+ assert_eq!(+ plan_open(vec![(p("/x/b.txt"), false)], &main),+ [OpenStep::Files("main".into(), vec![p("/x/b.txt")])]+ );+ let st = WindowsState::default();+ st.set_launch("main", cli);+ st.add_files("main", vec![p("/x/b.txt")]);+ assert_eq!(st.take_launch("main").unwrap().files, [p("/x/a.txt"), p("/x/b.txt")]);+ }++ #[test]+ fn files_inside_an_open_project_open_in_its_window_and_the_others_in_light_edit() {+ let windows = [+ w("main", Holds::Project(p("/proj"))),+ w("project-1", Holds::LightEdit),+ w("project-2", Holds::Project(p("/proj/sub"))),+ ];+ let steps = plan_open(+ vec![+ (p("/proj/src/a.rs"), false),+ (p("/x/b.txt"), false),+ (p("/proj/sub/c.rs"), false),+ (p("/projects/d.rs"), false),+ (p("/proj/e.rs"), false),+ ],+ &windows,+ );+ assert_eq!(+ steps,+ [+ OpenStep::Files("main".into(), vec![p("/proj/src/a.rs"), p("/proj/e.rs")]),+ // The deepest root wins.+ OpenStep::Files("project-2".into(), vec![p("/proj/sub/c.rs")]),+ // `/projects` is not inside `/proj`.+ OpenStep::Files("project-1".into(), vec![p("/x/b.txt"), p("/projects/d.rs")]),+ ]+ );+ }++ #[test]+ fn files_inside_a_folder_being_opened_open_in_its_project() {+ let opening = path_launch_of(Some(p("/a")), Vec::new());+ let windows = [w("main", pending_holds(Some(&opening))), w("project-1", Holds::Nothing)];+ let steps = plan_open(vec![(p("/a/x.rs"), false), (p("/b"), true), (p("/b/y.rs"), false)], &windows);+ assert_eq!(+ steps,+ [+ OpenStep::Launch("project-1".into(), path_launch_of(Some(p("/b")), vec![p("/b/y.rs")])),+ OpenStep::Files("main".into(), vec![p("/a/x.rs")]),+ ]+ );+ assert_eq!(+ plan_open(vec![(p("/c"), true), (p("/c/z.rs"), false)], &[]),+ [OpenStep::New(Some(p("/c")), vec![p("/c/z.rs")])]+ );+ }++ #[test]+ fn remote_projects_do_not_take_local_files() {+ let windows = [w("main", Holds::Other), w("project-1", Holds::LightEdit)];+ assert_eq!(+ plan_open(vec![(p("/home/me/a.rs"), false)], &windows),+ [OpenStep::Files("project-1".into(), vec![p("/home/me/a.rs")])]+ );+ }++ #[test]+ fn files_opened_while_running_take_a_free_window_else_a_new_one() {+ let free = [w("main", Holds::Project(p("/proj"))), w("project-1", Holds::Nothing)];+ assert_eq!(+ plan_open(vec![(p("/x/a.txt"), false)], &free),+ [OpenStep::Launch("project-1".into(), path_launch_of(None, vec![p("/x/a.txt")]))]+ );+ let busy = [w("main", Holds::Project(p("/proj"))), w("project-1", Holds::Other)];+ assert_eq!(plan_open(vec![(p("/x/a.txt"), false)], &busy), [OpenStep::New(None, vec![p("/x/a.txt")])]);+ }++ #[test]+ fn folders_opened_while_running_focus_their_window_else_open_as_projects() {+ let windows = [w("main", Holds::LightEdit), w("project-1", Holds::Project(p("/a")))];+ let steps = plan_open(vec![(p("/a"), true), (p("/b"), true), (p("/b"), true)], &windows);+ assert_eq!(steps, [OpenStep::Focus("project-1".into()), OpenStep::New(Some(p("/b")), Vec::new())]);+ // A window still opening the folder (pending launch) counts as having it.+ let opening = path_launch_of(Some(p("/a")), Vec::new());+ let windows = [w("project-2", pending_holds(Some(&opening)))];+ assert_eq!(plan_open(vec![(p("/a"), true)], &windows), [OpenStep::Focus("project-2".into())]);+ }+#[test]fn launches_are_taken_once() {let st = WindowsState::default();diff --git a/src-tauri/tauri.macos.conf.json b/src-tauri/tauri.macos.conf.jsonnew file mode 100644index 000000000..3993b3041--- /dev/null+++ b/src-tauri/tauri.macos.conf.json@@ -0,0 +1,99 @@+{+ "bundle": {+ "fileAssociations": [+ {+ "name": "Text and Source Code",+ "ext": [],+ "contentTypes": [+ "public.text",+ "public.plain-text",+ "public.source-code",+ "public.script",+ "public.shell-script",+ "public.json",+ "public.xml",+ "public.yaml",+ "public.python-script"+ ],+ "role": "Editor",+ "rank": "Alternate"+ },+ {+ "name": "Source Code",+ "ext": [+ "rs",+ "go",+ "py",+ "pyi",+ "pyw",+ "cjs",+ "scss",+ "less",+ "rst",+ "tex",+ "ps1",+ "bat",+ "fish",+ "kt",+ "kts",+ "gradle",+ "groovy",+ "scala",+ "sc",+ "ts",+ "mts",+ "cts",+ "jsx",+ "vue",+ "svelte",+ "dart",+ "cs",+ "fs",+ "fsx",+ "hs",+ "ex",+ "exs",+ "erl",+ "clj",+ "cljs",+ "edn",+ "lua",+ "zig",+ "nix",+ "jl",+ "ml",+ "mli",+ "tf",+ "hcl",+ "proto",+ "graphql",+ "gql",+ "sql",+ "http",+ "properties",+ "ini",+ "cfg",+ "conf",+ "env",+ "lock",+ "log",+ "diff",+ "patch",+ "gitignore",+ "dockerignore",+ "editorconfig",+ "dockerfile"+ ],+ "role": "Editor",+ "rank": "Alternate"+ },+ {+ "name": "Folder",+ "ext": [],+ "contentTypes": ["public.folder"],+ "role": "Viewer",+ "rank": "Alternate"+ }+ ]+ }+}diff --git a/src/editor/core/controller.test.ts b/src/editor/core/controller.test.tsindex 530483090..8079c4f8f 100644--- a/src/editor/core/controller.test.ts+++ b/src/editor/core/controller.test.ts@@ -65,6 +65,25 @@ describe("EditorController", () => {expect(openFilePaths(useTabs.getState())).toEqual(["/p/a.ts", "/p/b.ts"]);});+ it("reopens the LightEdit files the next time a window switches to LightEdit", async () => {+ ctrl = new EditorController(createMemoryBackend({ "/x/a.txt": "a", "/y/b.md": "b" }));+ ctrl.start();+ useProject.setState({ lightEdit: true });+ await ctrl.openFile("/x/a.txt", { focus: false });+ await ctrl.openFile("/y/b.md", { focus: false });+ // The LightEdit window closes with its tabs open.+ useProject.setState({ lightEdit: false });+ expect(openFilePaths(useTabs.getState())).toEqual([]);+ useProject.setState({ lightEdit: true });+ expect(openFilePaths(useTabs.getState())).toEqual(["/x/a.txt", "/y/b.md"]);+ // Closing every tab leaves nothing to reopen.+ ctrl.closeEverything();+ useProject.setState({ lightEdit: false });+ useProject.setState({ lightEdit: true });+ expect(openFilePaths(useTabs.getState())).toEqual([]);+ useProject.setState({ lightEdit: false });+ });+it("closes a tab by its input key", async () => {ctrl = new EditorController(createMemoryBackend());ctrl.start();diff --git a/src/editor/core/controller.ts b/src/editor/core/controller.tsindex a5f5efe20..c18c72ef6 100644--- a/src/editor/core/controller.ts+++ b/src/editor/core/controller.ts@@ -102,6 +102,9 @@ export function isTextInput(input: EditorInput): input is EditorInput & { path:export const useTabs = create<TabsState>(() => initialTabsState());+/** Session key of the LightEdit window: its tabs reopen the next time a window switches to LightEdit. */+export const LIGHT_EDIT_SESSION = "<lightEdit>";+export interface EditorStatus {path: string;doc: number;@@ -179,7 +182,7 @@ export class EditorController implements SlotHost {activeSlot: EditorSlot | null = null;private statusScheduled = false;private disposers: Array<() => void> = [];- /** Project root whose editor session is being tracked (null while switching). */+ /** Project root (or {@link LIGHT_EDIT_SESSION}) whose editor session is being tracked (null while switching). */private sessionRoot: string | null = null;private sessionTimer: ReturnType<typeof setTimeout> | undefined;/** Restored caret / scroll per path, applied when the file's first slot is created. */@@ -237,6 +240,7 @@ export class EditorController implements SlotHost {this.nav.clear();this.edits.clear();if (root) this.restoreSession(root);+ else if (s.lightEdit) this.restoreSession(LIGHT_EDIT_SESSION);}}),);diff --git a/src/features/app/__tests__/lightEditClose.test.ts b/src/features/app/__tests__/lightEditClose.test.tsnew file mode 100644index 000000000..a002941fb--- /dev/null+++ b/src/features/app/__tests__/lightEditClose.test.ts@@ -0,0 +1,62 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { useProject } from "@/platform/project";+import { provideEditorService, type EditorInput, type OpenEditorTab } from "@/workbench/contributions";+import { installLightEditAutoClose } from "../windows";++/** An editor service whose tabs the test drives. */+function fakeEditor() {+ const listeners = new Set<(input: EditorInput | null) => void>();+ let tabs: string[] = [];+ provideEditorService({+ openFile: async () => {},+ openInput: async () => {},+ activePath: () => tabs.at(-1) ?? null,+ activeCursor: () => null,+ saveAll: async () => {},+ openTabs: () => tabs.map((path) => ({ input: { kind: "file", key: path, path } }) as OpenEditorTab),+ onActiveInputChange: (fn) => {+ listeners.add(fn);+ return () => listeners.delete(fn);+ },+ });+ return {+ setTabs(next: string[]) {+ tabs = next;+ const path = next.at(-1);+ for (const fn of listeners) fn(path ? ({ kind: "file", key: path, path } as EditorInput) : null);+ },+ };+}++describe("LightEdit window", () => {+ const close = vi.fn(async () => {});+ let dispose: () => void = () => {};+ beforeEach(() => close.mockClear());+ afterEach(() => {+ dispose();+ useProject.setState({ project: null, lightEdit: false });+ });++ it("closes when its last editor tab closes", () => {+ const editor = fakeEditor();+ useProject.setState({ project: null, lightEdit: true });+ dispose = installLightEditAutoClose(close);+ editor.setTabs(["/x/a.txt", "/x/b.txt"]);+ editor.setTabs(["/x/a.txt"]);+ expect(close).not.toHaveBeenCalled();+ editor.setTabs([]);+ expect(close).toHaveBeenCalledTimes(1);+ });++ it("stays open in a project window or while leaving LightEdit", () => {+ const editor = fakeEditor();+ dispose = installLightEditAutoClose(close);+ useProject.setState({ project: { root: "/p", name: "p" }, lightEdit: false } as never);+ editor.setTabs(["/p/a.rs"]);+ editor.setTabs([]);+ // Closing the project (or the LightEdit session) closes every tab after `lightEdit` is off.+ useProject.setState({ project: null, lightEdit: false });+ editor.setTabs([]);+ expect(close).not.toHaveBeenCalled();+ });+});diff --git a/src/features/app/index.ts b/src/features/app/index.tsindex 687d3d63e..a5cb87d25 100644--- a/src/features/app/index.ts+++ b/src/features/app/index.ts@@ -15,7 +15,7 @@ import { installMenuBridge } from "./menuBridge";import { NewProjectOverlay } from "./NewProject";import { projectActions, registerPowerSaveBanner } from "./projectActions";import { installWindowTitle } from "./title";-import { installLaunchHandling, windowActions } from "./windows";+import { installLaunchHandling, installLightEditAutoClose, windowActions } from "./windows";/** The UI locale of a secondary (Settings) window. */export const activateLocale = installLocaleSync;@@ -42,6 +42,7 @@ export function activate(): () => void {installWindowTitle(),installCloseGuard(),installLaunchHandling(),+ installLightEditAutoClose(),];let disposed = false;void buildInfo().then((b) => {diff --git a/src/features/app/windows.ts b/src/features/app/windows.tsindex 6d7206948..09c3c66f2 100644--- a/src/features/app/windows.ts+++ b/src/features/app/windows.ts@@ -296,6 +296,25 @@ export function windowActions(): Action[] {];}+async function closeThisWindow(): Promise<void> {+ if (!isTauri()) return;+ const { getCurrentWindow } = await import("@tauri-apps/api/window");+ await getCurrentWindow().close();+}++/**+ * LightEdit: closing its last editor tab closes the window (through the close guard,+ * so the last window shows the Welcome screen instead).+ */+export function installLightEditAutoClose(closeWindow: () => Promise<void> = closeThisWindow): () => void {+ const editor = maybeEditorService();+ const off = editor?.onActiveInputChange?.((input) => {+ if (input || !useProject.getState().lightEdit || editor?.openTabs?.().length) return;+ void closeWindow().catch((e) => console.warn("could not close the window", e));+ });+ return () => off?.();+}+export function installLaunchHandling(): () => void {if (!isTauri()) return () => {};let disposed = false;diff --git a/src/features/welcome/session.test.ts b/src/features/welcome/session.test.tsindex a45f5413b..45c464d37 100644--- a/src/features/welcome/session.test.ts+++ b/src/features/welcome/session.test.ts@@ -46,6 +46,13 @@ describe("reopenLastProject", () => {expect(openProject).not.toHaveBeenCalled();});+ it("leaves files opened at launch in LightEdit", async () => {+ provideStartupLaunch(Promise.resolve().then(() => useProject.setState({ lightEdit: true })));+ await reopenLastProject();+ expect(openProject).not.toHaveBeenCalled();+ useProject.setState({ lightEdit: false });+ });+it("reopens the last project when the launch named none", async () => {provideStartupLaunch(Promise.resolve());await reopenLastProject();diff --git a/src/features/welcome/session.ts b/src/features/welcome/session.tsindex cb6a1356b..65c4b98a5 100644--- a/src/features/welcome/session.ts+++ b/src/features/welcome/session.ts@@ -106,9 +106,9 @@ export async function reopenLastProject(): Promise<void> {/* use the local preference */}if (!reopenEnabled(settings, useSession.getState().reopenPref)) return;- // A project passed on the command line wins over the last session's.+ // A project or files passed on the command line (or from Finder) win over the last session's.await startupLaunchHandled();- if (useProject.getState().project) return;+ if (useProject.getState().project || useProject.getState().lightEdit) return;await reopen(path);}diff --git a/src/workbench/EditorArea.tsx b/src/workbench/EditorArea.tsxindex 64f980da2..6d55ce12f 100644--- a/src/workbench/EditorArea.tsx+++ b/src/workbench/EditorArea.tsx@@ -1,11 +1,14 @@import { executeAction, useActions } from "@/platform/actions";import { shortcutLabel } from "@/platform/keymap";+import { useProject } from "@/platform/project";import { T } from "@/ui";import { useWorkbenchSlots } from "./contributions";import { ErrorBoundary, Slot } from "./ErrorBoundary";import styles from "./EditorArea.module.css";-const HINTS: Array<{ label: string; action?: string; fallback?: string }> = [+type Hint = { label: string; action?: string; fallback?: string };++const HINTS: Hint[] = [{ label: "Search Everywhere", action: "navigate.searchEverywhere", fallback: "Double ⇧" },{ label: "Go to File", action: "navigate.gotoFile" },{ label: "Recent Files", action: "navigate.recentFiles" },@@ -13,13 +16,20 @@ const HINTS: Array<{ label: string; action?: string; fallback?: string }> = [{ label: "Drop files here to open them" },];+/** LightEdit has no project to navigate: only opening files works there. */+const LIGHT_EDIT_HINTS: Hint[] = [+ { label: "Open File", action: "file.openFile" },+ { label: "Drop files here to open them" },+];+/** IDEA's empty editor: a few navigation hints with their shortcuts. */export function EmptyEditor() {const actions = useActions((s) => s.actions);+ const lightEdit = useProject((s) => s.lightEdit);return (<div className={styles.empty}><dl className={styles.hints}>- {HINTS.map((h) => {+ {(lightEdit ? LIGHT_EDIT_HINTS : HINTS).map((h) => {const keys = h.action ? (shortcutLabel(h.action) ?? h.fallback) : undefined;const runnable = !!h.action && actions.has(h.action);return (diff --git a/src/workbench/lightEdit.test.tsx b/src/workbench/lightEdit.test.tsxindex fffebdc13..560753743 100644--- a/src/workbench/lightEdit.test.tsx+++ b/src/workbench/lightEdit.test.tsx@@ -5,6 +5,7 @@ import { evaluateWhen } from "@/platform/context";import { useProject } from "@/platform/project";import { activateWorkbench } from "./activate";import { registerStatusItem, registerTitleItem, registerToolWindow } from "./contributions";+import { EmptyEditor } from "./EditorArea";import { chooseProjectWindow } from "./projectWindow";import { Workbench } from "./Workbench";@@ -51,6 +52,21 @@ describe("LightEdit window", () => {expect(screen.queryByText("Welcome to OpenIDEA")).toBeNull();});+ it("hints only at opening files in an empty editor", () => {+ render(<EmptyEditor />);+ expect(screen.getByText("Open File")).toBeInTheDocument();+ expect(screen.getByText("Drop files here to open them")).toBeInTheDocument();+ for (const project of ["Search Everywhere", "Go to File", "Recent Files", "Navigation Bar"])+ expect(screen.queryByText(project)).toBeNull();+ });++ it("keeps the navigation hints in a project window", () => {+ useProject.setState({ lightEdit: false });+ render(<EmptyEditor />);+ expect(screen.getByText("Go to File")).toBeInTheDocument();+ expect(screen.queryByText("Open File")).toBeNull();+ });+it("sets the context keys that keep project actions off", () => {const dispose = activateWorkbench();expect(evaluateWhen("lightEdit")).toBe(true);