feat: change selections

Author: Myriad-Dreamin

crates/tinymist/src/cmd.rs

@@ -26,6 +26,8 @@ use crate::lsp::query::{run_query, LspClientExt};
 use crate::tool::ast::AstRepr;
 use crate::tool::package::InitTask;
 
+mod pin_focus;
+
 /// See [`ProjectTask`].
 #[derive(Debug, Clone, Default, Deserialize)]
 struct ExportOpts {
@@ -63,6 +65,8 @@ struct ExportSyntaxRangeOpts {
 }
 
 /// Here are implemented the handlers for each command.
+/// Some command group are placed in the sub crates:
+/// - [`pin_focus`] implements commands for pinning and focusing documents.
 impl ServerState {
     /// Export the current document as PDF file(s).
     pub fn export_pdf(&mut self, req_id: RequestId, mut args: Vec<JsonValue>) -> ScheduledResult {
@@ -277,35 +281,6 @@ impl ServerState {
         just_ok(JsonValue::Null)
     }
 
-    /// Pin main file to some path.
-    pub fn pin_document(&mut self, mut args: Vec<JsonValue>) -> AnySchedulableResponse {
-        let entry = get_arg!(args[0] as Option<PathBuf>).map(From::from);
-
-        let update_result = self.pin_main_file(entry.clone());
-        update_result.map_err(|err| internal_error(format!("could not pin file: {err}")))?;
-
-        log::info!("file pinned: {entry:?}");
-        just_ok(JsonValue::Null)
-    }
-
-    /// Focus main file to some path.
-    pub fn focus_document(&mut self, mut args: Vec<JsonValue>) -> AnySchedulableResponse {
-        let entry = get_arg!(args[0] as Option<PathBuf>).map(From::from);
-
-        if !self.ever_manual_focusing {
-            self.ever_manual_focusing = true;
-            log::info!("first manual focusing is coming");
-        }
-
-        let ok = self.focus_main_file(entry.clone());
-        let ok = ok.map_err(|err| internal_error(format!("could not focus file: {err}")))?;
-
-        if ok {
-            log::info!("file focused: {entry:?}");
-        }
-        just_ok(JsonValue::Null)
-    }
-
     /// Starts a preview instance.
     #[cfg(feature = "preview")]
     pub fn do_start_preview(

crates/tinymist/src/cmd/pin_focus.rs

@@ -0,0 +1,55 @@
+//! Tinymist LSP commands: pinning and focusing documents.
+
+use super::*;
+
+type Selections = Vec<LspRange>;
+
+/// Extra options for the focus command.
+#[derive(Debug, Clone, Default, Deserialize)]
+struct FocusDocOpts {
+    /// An optional list of selections to be set after focusing. The first
+    /// selection is the primary one.
+    #[serde(default)]
+    selections: Option<Selections>,
+}
+
+impl ServerState {
+    /// Pins main file to some path.
+    pub fn pin_document(&mut self, mut args: Vec<JsonValue>) -> AnySchedulableResponse {
+        let entry = get_arg!(args[0] as Option<PathBuf>).map(From::from);
+        let opts = get_arg_or_default!(args[1] as FocusDocOpts);
+
+        let update_result = self.pin_main_file(entry.clone());
+        update_result.map_err(|err| internal_error(format!("could not pin file: {err}")))?;
+
+        self.do_change_selections(opts.selections);
+
+        log::info!("file pinned: {entry:?}");
+        just_ok(JsonValue::Null)
+    }
+
+    /// Focuses main file to some path.
+    pub fn focus_document(&mut self, mut args: Vec<JsonValue>) -> AnySchedulableResponse {
+        let entry = get_arg!(args[0] as Option<PathBuf>).map(From::from);
+
+        if !self.ever_manual_focusing {
+            self.ever_manual_focusing = true;
+            log::info!("first manual focusing is coming");
+        }
+
+        let ok = self.focus_main_file(entry.clone());
+        let ok = ok.map_err(|err| internal_error(format!("could not focus file: {err}")))?;
+
+        if ok {
+            log::info!("file focused: {entry:?}");
+        }
+        just_ok(JsonValue::Null)
+    }
+
+    /// Changes the selections.
+    pub fn change_selections(&mut self, mut args: Vec<JsonValue>) -> AnySchedulableResponse {
+        let selections = get_arg!(args[0] as Selections);
+        self.do_change_selections(Some(selections));
+        just_ok(JsonValue::Null)
+    }
+}

crates/tinymist/src/input.rs

@@ -1,6 +1,6 @@
 use lsp_types::*;
 use reflexo_typst::Bytes;
-use tinymist_query::{to_typst_range, PositionEncoding};
+use tinymist_query::{to_typst_range, LspRange, PositionEncoding};
 use tinymist_std::error::prelude::*;
 use tinymist_std::ImmutPath;
 use typst::{diag::FileResult, syntax::Source};
@@ -193,6 +193,16 @@ impl ServerState {
             Ok(false) => {}
         }
     }
+
+    /// Does the selection change. It accepts an optional list of selections.
+    /// The first selection is the primary one.
+    pub fn do_change_selections(&mut self, selections: Option<Vec<LspRange>>) -> Option<()> {
+        let selections = selections?;
+        let primary_selection = selections.into_iter().next()?;
+
+        self.focusing_selection = Some(primary_selection);
+        Some(())
+    }
 }
 
 /// Task input resolution.

crates/tinymist/src/server.rs

@@ -7,7 +7,7 @@ use lsp_types::request::ShowMessageRequest;
 use lsp_types::*;
 use reflexo::debug_loc::LspPosition;
 use sync_ls::*;
-use tinymist_query::{OnExportRequest, ServerInfoResponse};
+use tinymist_query::{LspRange, OnExportRequest, ServerInfoResponse};
 use tinymist_std::error::prelude::*;
 use tinymist_std::ImmutPath;
 use tinymist_task::ProjectTask;
@@ -76,7 +76,11 @@ pub struct ServerState {
     pub pinning_by_browsing_preview: bool,
     /// The client focusing file.
     pub focusing: Option<ImmutPath>,
-    /// The client focusing position.
+    /// The client focusing range. There might be multiple ranges selected by
+    /// the client at the same time, but we only record the primary one.
+    pub focusing_selection: Option<LspRange>,
+    /// The client focusing position, implicitly. It is inferred from the LSP
+    /// requests so may be inaccurate.
     pub implicit_position: Option<LspPosition>,
     /// The client ever focused implicitly by activities.
     pub ever_focusing_by_activities: bool,
@@ -136,6 +140,7 @@ impl ServerState {
             pinning_by_preview: false,
             pinning_by_browsing_preview: false,
             focusing: None,
+            focusing_selection: None,
             implicit_position: None,
             formatter,
             user_action: UserActionTask,
@@ -273,6 +278,7 @@ impl ServerState {
             .with_command("tinymist.doClearCache", State::clear_cache)
             .with_command("tinymist.pinMain", State::pin_document)
             .with_command("tinymist.focusMain", State::focus_document)
+            .with_command("tinymist.changeSelections", State::change_selections)
             .with_command("tinymist.doInitTemplate", State::init_template)
             .with_command("tinymist.doGetTemplateEntry", State::get_template_entry)
             .with_command_("tinymist.interactCodeContext", State::interact_code_context)

editors/vscode/src/extension.shared.ts

@@ -103,6 +103,9 @@ export async function tinymistActivate(
 
   configureEditorAndLanguage(context, trait);
 
+  // todo: a better model is `focusing.transfer(newClient)`, since the old request must not be cancelled and must
+  // be sent to the new client.
+  extensionState.mut.focusing.reset();
   // Initializes language client
   if (extensionState.features.lsp) {
     const executable = tinymist.probeEnvPath("tinymist.serverPath", config.serverPath);

editors/vscode/src/extension.ts

@@ -152,11 +152,11 @@ async function languageActivate(context: IContext) {
   // Find first document to focus
   const editor = window.activeTextEditor;
   if (isTypstDocument(editor?.document)) {
-    focusDocPath(editor.document);
+    focusDoc(editor.document, editor);
   } else {
     window.visibleTextEditors.forEach((editor) => {
       if (isTypstDocument(editor.document)) {
-        focusDocPath(editor.document);
+        focusDoc(editor.document, editor);
       }
     });
   }
@@ -170,28 +170,16 @@ async function languageActivate(context: IContext) {
       // if (langId === "plaintext") {
       //     console.log("plaintext", langId, editor?.document.uri.fsPath);
       // }
-      if (!isTypstDocument(editor?.document)) {
-        // console.log("not typst", langId, editor?.document.uri.fsPath);
-        return focusDocPath(undefined);
-      }
-      return focusDocPath(editor?.document);
+      return focusDoc(isTypstDocument(editor?.document) ? editor?.document : undefined, editor);
     }),
-  );
-  context.subscriptions.push(
     vscode.workspace.onDidOpenTextDocument((doc: vscode.TextDocument) => {
       if (doc.isUntitled && window.activeTextEditor?.document === doc) {
-        if (isTypstDocument(doc)) {
-          return focusDocPath(doc);
-        } else {
-          return focusDocPath(undefined);
-        }
+        return focusDoc(isTypstDocument(doc) ? doc : undefined, window.activeTextEditor);
       }
     }),
-  );
-  context.subscriptions.push(
     vscode.workspace.onDidCloseTextDocument((doc: vscode.TextDocument) => {
       if (extensionState.mut.focusing.doc === doc) {
-        focusDocPath(undefined);
+        focusDoc(undefined);
       }
     }),
   );
@@ -244,21 +232,15 @@ async function openExternal(target: string): Promise<void> {
   await vscode.env.openExternal(uri);
 }
 
-function focusDocPath(doc: vscode.TextDocument | undefined) {
-  const fsPath = doc
-    ? doc.isUntitled
-      ? "/untitled/" + doc.uri.fsPath
-      : doc.uri.fsPath
-    : undefined;
-
+function focusDoc(doc: vscode.TextDocument | undefined, editor?: TextEditor | undefined) {
   // Changes focus state.
-  extensionState.mut.focusing.focusMain(doc, fsPath);
+  extensionState.mut.focusing.focusMain(doc, editor);
 
   // Changes status bar.
   const formatString = statusBarFormatString();
   triggerStatusBar(
     // Shows the status bar only the last focusing file is not closed (opened)
-    !!formatString && !!(fsPath || extensionState.mut.focusing.doc?.isClosed === false),
+    !!formatString && !!(extensionState.mut.focusing.doc?.isClosed === false),
   );
 }
 

editors/vscode/src/focus.ts

@@ -3,36 +3,83 @@ import * as vscode from "vscode";
 
 export class FocusState {
   private mainTimeout: NodeJS.Timeout | undefined = undefined;
-  private mainPath: string | undefined = undefined;
   private mainDoc: vscode.TextDocument | undefined = undefined;
+  private subscribedSelection: boolean = false;
+  private lastSyncPath?: string;
 
+  get doc() {
+    return this.mainDoc;
+  }
+
+  /**
+   * Resets the state of the focus. This is called before the extension is
+   * (re-)activated.
+   */
   reset() {
     if (this.mainTimeout) {
       clearTimeout(this.mainTimeout);
     }
+    this.lastSyncPath = undefined;
   }
 
-  // Informs the server after a while. This is not done intemediately to avoid
-  // the cases that the user removes the file from the editor and then opens
-  // another one in a short time.
-  focusMain(doc?: vscode.TextDocument, fsPath?: string) {
-    if (this.mainTimeout) {
-      clearTimeout(this.mainTimeout);
-    }
+  /**
+   * Informs the server after a while. This is not done intemediately to avoid
+   * the cases that the user removes the file from the editor and then opens
+   * another one in a short time.
+   */
+  focusMain(doc?: vscode.TextDocument, editor?: vscode.TextEditor) {
     this.mainDoc = doc;
     if (this.mainDoc?.isClosed) {
       this.mainDoc = undefined;
     }
-    this.mainPath = fsPath;
+
+    this.subscribeChange();
+    this.lspChangeSelect(doc, editor ? () => editor.selections : undefined);
+  }
+
+  /**
+   * Lazily subscribes to the selection change event.
+   */
+  private subscribeChange() {
+    if (this.subscribedSelection) {
+      return;
+    }
+    this.subscribedSelection = true;
+
+    vscode.window.onDidChangeTextEditorSelection((event) => {
+      if (this.mainDoc && uriEquals(event.textEditor.document.uri, this.mainDoc.uri)) {
+        this.lspChangeSelect(event.textEditor.document, () => event.selections);
+      }
+    });
+  }
+
+  private lspChangeSelect(doc?: vscode.TextDocument, select?: () => readonly vscode.Selection[]) {
+    if (this.mainTimeout) {
+      clearTimeout(this.mainTimeout);
+    }
     this.mainTimeout = setTimeout(async () => {
-      tinymist.executeCommand("tinymist.focusMain", [fsPath]);
+      const fsPath = doc
+        ? doc.isUntitled
+          ? "/untitled/" + doc.uri.fsPath
+          : doc.uri.fsPath
+        : undefined;
+      const opts = select ? { selections: await this.convertLspSelections(select()) } : undefined;
+
+      if (this.lastSyncPath === fsPath) {
+        tinymist.executeCommand("tinymist.changeSelections", [opts?.selections]);
+      } else {
+        tinymist.executeCommand("tinymist.focusMain", [fsPath, opts]);
+      }
     }, 100);
   }
 
-  get path() {
-    return this.mainPath;
-  }
-  get doc() {
-    return this.mainDoc;
+  async convertLspSelections(selections: readonly vscode.Selection[]) {
+    const client = await tinymist.getClient();
+
+    return selections.map((s) => client.code2ProtocolConverter.asRange(s));
   }
 }
+
+function uriEquals(lhs: vscode.Uri, rhs: vscode.Uri) {
+  return lhs.toString(true) === rhs.toString(true);
+}