@opensumi/sumi 3.6.4 → 3.6.5-next-1734685380.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opensumi/sumi",
-  "version": "3.6.4",
+  "version": "3.6.5-next-1734685380.0",
   "typings": "index.d.ts",
   "license": "MIT",
   "repository": {
@@ -12,11 +12,11 @@
     "build": "tsx ./build.ts"
   },
   "dependencies": {
-    "@opensumi/ide-components": "3.6.4",
+    "@opensumi/ide-components": "3.6.5-next-1734685380.0",
     "vscode-uri": "3.0.2"
   },
   "devDependencies": {
     "@types/react": "^18.2.0"
   },
-  "gitHead": "23eb1f073234e9e79a32f81c7384924fc459aa69"
+  "gitHead": "f3f687ab92b2f35018432c403476b9ee363071cc"
 }

package/sumi-worker/worker.editor.d.ts

@@ -124,6 +124,10 @@ declare module 'sumi-worker' {
      * Render the line numbers with values relative to the primary cursor location.
      */
     Relative = 2,
+    /**
+     * Render the line numbers on every 10th line number.
+     */
+    Interval = 3,
   }
 
   /**

package/sumi.d.ts

@@ -27,6 +27,7 @@ declare module 'sumi' {
     TextEditor,
     TextEditorEdit,
     ExtensionContext as VSCodeExtensionContext,
+    ViewBadge,
     // eslint-disable-next-line import/no-unresolved
   } from 'vscode';
 
@@ -472,10 +473,12 @@ declare module 'sumi' {
      * @example
      * ```ts
      *  const tabbar = kaitian.layout.getTabbarHandler('TabbarIconTest');
-     *  tabbar.setBadge('12');
+     *  tabbar.setBadge({value:20,tooltip:'20'});
+     *  or
+     *  tabbar.setBadge('20');
      * ```
      */
-    setBadge(badge: string): void;
+    setBadge(badge?: string | ViewBadge): void;
 
     activate(): void;
 

package/vscode/typings/vscode.authentication.d.ts

@@ -105,6 +105,11 @@ declare module 'vscode' {
      * Note: you cannot use this option with any other options that prompt the user like {@link createIfNone}.
      */
     silent?: boolean;
+
+    /**
+     * The account that you would like to get a session for. This is passed down to the Authentication Provider to be used for creating the correct session.
+     */
+    account?: AuthenticationSessionAccountInformation;
   }
 
   /**
@@ -165,6 +170,18 @@ declare module 'vscode' {
     readonly changed?: ReadonlyArray<AuthenticationSession>;
   }
 
+  /**
+   * The options passed in to the {@link AuthenticationProvider.getSessions} and
+   * {@link AuthenticationProvider.createSession} call.
+   */
+  export interface AuthenticationProviderSessionOptions {
+    /**
+     * The account that is being asked about. If this is passed in, the provider should
+     * attempt to return the sessions that are only related to this account.
+     */
+    account?: AuthenticationSessionAccountInformation;
+  }
+
   /**
    * A provider for performing authentication to a service.
    */
@@ -181,7 +198,7 @@ declare module 'vscode' {
      * these permissions, otherwise all sessions should be returned.
      * @returns A promise that resolves to an array of authentication sessions.
      */
-    getSessions(scopes?: string[]): Thenable<ReadonlyArray<AuthenticationSession>>;
+    getSessions(scopes?: string[], options?: AuthenticationProviderSessionOptions): Thenable<ReadonlyArray<AuthenticationSession>>;
 
     /**
      * Prompts a user to login.
@@ -196,8 +213,8 @@ declare module 'vscode' {
      * @param scopes A list of scopes, permissions, that the new session should be created with.
      * @returns A promise that resolves to an authentication session.
      */
-    createSession(scopes: string[]): Thenable<AuthenticationSession>;
-
+    createSession(scopes: string[], options: AuthenticationProviderSessionOptions): Thenable<AuthenticationSession>;
+    
     /**
      * Removes the session corresponding to session id.
      *
@@ -259,6 +276,20 @@ declare module 'vscode' {
 		 */
 		export function getSession(providerId: string, scopes: readonly string[], options?: AuthenticationGetSessionOptions): Thenable<AuthenticationSession | undefined>;
 
+    /**
+     * Get all accounts that the user is logged in to for the specified provider.
+     * Use this paired with {@link getSession} in order to get an authentication session for a specific account.
+     *
+     * Currently, there are only two authentication providers that are contributed from built in extensions
+     * to the editor that implement GitHub and Microsoft authentication: their providerId's are 'github' and 'microsoft'.
+     *
+     * Note: Getting accounts does not imply that your extension has access to that account or its authentication sessions. You can verify access to the account by calling {@link getSession}.
+     *
+     * @param providerId The id of the provider to use
+     * @returns A thenable that resolves to a readonly array of authentication accounts.
+     */
+    export function getAccounts(providerId: string): Thenable<readonly AuthenticationSessionAccountInformation[]>;
+
     /**
      * An {@link Event} which fires when the authentication sessions of an authentication provider have
      * been added, removed, or changed.

package/vscode/typings/vscode.d.ts

@@ -1054,6 +1054,12 @@ declare module 'vscode' {
      * Whether the current window is focused.
      */
     readonly focused: boolean;
+
+    /**
+     * Whether the window has been interacted with recently. This will change
+     * immediately on activity, or after a short time of user inactivity.
+     */
+    readonly active: boolean;
   }
 
   /**
@@ -1618,9 +1624,47 @@ declare module 'vscode' {
     canSelectMany?: boolean;
 
     /**
-		* An optional interface to implement drag and drop in the tree view.
-		*/
-		dragAndDropController?: TreeDragAndDropController<T>;
+    * An optional interface to implement drag and drop in the tree view.
+    */
+    dragAndDropController?: TreeDragAndDropController<T>;
+
+    /**
+     * By default, when the children of a tree item have already been fetched, child checkboxes are automatically managed based on the checked state of the parent tree item.
+     * If the tree item is collapsed by default (meaning that the children haven't yet been fetched) then child checkboxes will not be updated.
+     * To override this behavior and manage child and parent checkbox state in the extension, set this to `true`.
+     *
+     * Examples where {@link TreeViewOptions.manageCheckboxStateManually} is false, the default behavior:
+     *
+     * 1. A tree item is checked, then its children are fetched. The children will be checked.
+     *
+     * 2. A tree item's parent is checked. The tree item and all of it's siblings will be checked.
+     *   - [ ] Parent
+     *     - [ ] Child 1
+     *     - [ ] Child 2
+     *   When the user checks Parent, the tree will look like this:
+     *   - [x] Parent
+     *     - [x] Child 1
+     *     - [x] Child 2
+     *
+     * 3. A tree item and all of it's siblings are checked. The parent will be checked.
+     *   - [ ] Parent
+     *     - [ ] Child 1
+     *     - [ ] Child 2
+     *   When the user checks Child 1 and Child 2, the tree will look like this:
+     *   - [x] Parent
+     *     - [x] Child 1
+     *     - [x] Child 2
+     *
+     * 4. A tree item is unchecked. The parent will be unchecked.
+     *   - [x] Parent
+     *     - [x] Child 1
+     *     - [x] Child 2
+     *   When the user unchecks Child 1, the tree will look like this:
+     *   - [ ] Parent
+     *     - [ ] Child 1
+     *     - [x] Child 2
+     */
+    manageCheckboxStateManually?: boolean;
   }
 
   /**
@@ -1854,6 +1898,11 @@ declare module 'vscode' {
      */
     readonly onDidChangeVisibility: Event<TreeViewVisibilityChangeEvent>;
 
+    /**
+     * An event to signal that an element or root has either been checked or unchecked.
+     */
+    readonly onDidChangeCheckboxState: Event<TreeCheckboxChangeEvent<T>>;
+
     /**
      * An optional human-readable message that will be rendered in the view.
      * Setting the message to null, undefined, or empty string will remove the message from the view.
@@ -1872,6 +1921,12 @@ declare module 'vscode' {
      */
     description?: string;
 
+    /**
+     * The badge to display for this TreeView.
+     * To remove the badge, set to undefined.
+     */
+    badge?: ViewBadge | undefined;
+
     /**
      * Reveals the given element in the tree view.
      * If the tree view is not visible then the tree view is shown and element is revealed.
@@ -1887,6 +1942,24 @@ declare module 'vscode' {
     reveal(element: T, options?: { select?: boolean, focus?: boolean, expand?: boolean | number }): Thenable<void>;
   }
 
+
+  /**
+   * A badge presenting a value for a view
+   */
+  export interface ViewBadge {
+
+    /**
+     * A label to present in tooltip for the badge.
+     */
+    readonly tooltip: string;
+
+    /**
+     * The value to present in the badge.
+     */
+    readonly value: number;
+  }
+
+
   /**
    * Label describing the [Tree item](#TreeItem)
    */
@@ -1905,6 +1978,30 @@ declare module 'vscode' {
 
   }
 
+  /**
+   * Checkbox state of the tree item
+   */
+  export enum TreeItemCheckboxState {
+    /**
+     * Determines an item is unchecked
+     */
+    Unchecked = 0,
+    /**
+     * Determines an item is checked
+     */
+    Checked = 1
+  }
+
+  /**
+   * An event describing the change in a tree item's checkbox state.
+   */
+  export interface TreeCheckboxChangeEvent<T> {
+    /**
+     * The items that were checked or unchecked.
+     */
+    readonly items: ReadonlyArray<[T, TreeItemCheckboxState]>;
+  }
+
   /**
  * Collapsible state of the tree item
  */
@@ -2061,6 +2158,25 @@ declare module 'vscode' {
      */
     accessibilityInformation?: AccessibilityInformation;
 
+    /**
+     * {@link TreeItemCheckboxState TreeItemCheckboxState} of the tree item.
+     * {@link TreeDataProvider.onDidChangeTreeData onDidChangeTreeData} should be fired when {@link TreeItem.checkboxState checkboxState} changes.
+     */
+    checkboxState?: TreeItemCheckboxState | {
+      /**
+       * The {@link TreeItemCheckboxState} of the tree item
+       */
+      readonly state: TreeItemCheckboxState;
+      /**
+       * A tooltip for the checkbox
+       */
+      readonly tooltip?: string;
+      /**
+       * Accessibility information used when screen readers interact with this checkbox
+       */
+      readonly accessibilityInformation?: AccessibilityInformation;
+    };
+
     /**
      * @param label A human-readable string describing this item
      * @param collapsibleState {@link TreeItemCollapsibleState} of the tree item. Default is {@link TreeItemCollapsibleState.None}
@@ -2952,8 +3068,43 @@ declare module 'vscode' {
      *   without providing an exit code.
      */
     readonly code: number | undefined;
+
+    /**
+		 * The reason that triggered the exit of a terminal.
+		 */
+		readonly reason: TerminalExitReason;
   }
 
+	/**
+	 * Terminal exit reason kind.
+	 */
+	export enum TerminalExitReason {
+		/**
+		 * Unknown reason.
+		 */
+		Unknown = 0,
+
+		/**
+		 * The window closed/reloaded.
+		 */
+		Shutdown = 1,
+
+		/**
+		 * The shell process exited.
+		 */
+		Process = 2,
+
+		/**
+		 * The user closed the terminal.
+		 */
+		User = 3,
+
+		/**
+		 * An extension disposed the terminal.
+		 */
+		Extension = 4,
+	}
+
   export interface Terminal {
 
     /**
@@ -2971,6 +3122,18 @@ declare module 'vscode' {
      */
     readonly state: TerminalState;
 
+    /**
+     * An object that contains [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered
+     * features for the terminal. This will always be `undefined` immediately after the terminal
+     * is created. Listen to {@link window.onDidChangeTerminalShellIntegration} to be notified
+     * when shell integration is activated for a terminal.
+     *
+     * Note that this object may remain undefined if shell integration never activates. For
+     * example Command Prompt does not support shell integration and a user's shell setup could
+     * conflict with the automatic shell integration activation.
+     */
+    readonly shellIntegration: TerminalShellIntegration | undefined;
+
     /**
      * The object used to initialize the terminal, this is useful for example to detecting the
      * shell type of when the terminal was not launched by this extension or for detecting what
@@ -3042,6 +3205,316 @@ declare module 'vscode' {
     readonly isInteractedWith: boolean;
   }
 
+  /**
+   * [Shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered capabilities owned by a terminal.
+   */
+  export interface TerminalShellIntegration {
+    /**
+     * The current working directory of the terminal. This {@link Uri} may represent a file on
+     * another machine (eg. ssh into another machine). This requires the shell integration to
+     * support working directory reporting.
+     */
+    readonly cwd: Uri | undefined;
+
+    /**
+     * Execute a command, sending ^C as necessary to interrupt any running command if needed.
+     *
+     * @param commandLine The command line to execute, this is the exact text that will be sent
+     * to the terminal.
+     *
+     * @example
+     * // Execute a command in a terminal immediately after being created
+     * const myTerm = window.createTerminal();
+     * window.onDidChangeTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
+     *   if (terminal === myTerm) {
+     *     const execution = shellIntegration.executeCommand('echo "Hello world"');
+     *     window.onDidEndTerminalShellExecution(event => {
+     *       if (event.execution === execution) {
+     *         console.log(`Command exited with code ${event.exitCode}`);
+     *       }
+     *     });
+     *   }
+     * }));
+     * // Fallback to sendText if there is no shell integration within 3 seconds of launching
+     * setTimeout(() => {
+     *   if (!myTerm.shellIntegration) {
+     *     myTerm.sendText('echo "Hello world"');
+     *     // Without shell integration, we can't know when the command has finished or what the
+     *     // exit code was.
+     *   }
+     * }, 3000);
+     *
+     * @example
+     * // Send command to terminal that has been alive for a while
+     * const commandLine = 'echo "Hello world"';
+     * if (term.shellIntegration) {
+     *   const execution = shellIntegration.executeCommand({ commandLine });
+     *   window.onDidEndTerminalShellExecution(event => {
+     *     if (event.execution === execution) {
+     *       console.log(`Command exited with code ${event.exitCode}`);
+     *     }
+     *   });
+     * } else {
+     *   term.sendText(commandLine);
+     *   // Without shell integration, we can't know when the command has finished or what the
+     *   // exit code was.
+     * }
+     */
+    executeCommand(commandLine: string): TerminalShellExecution;
+
+    /**
+     * Execute a command, sending ^C as necessary to interrupt any running command if needed.
+     *
+     * *Note* This is not guaranteed to work as [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)
+     * must be activated. Check whether {@link TerminalShellExecution.exitCode} is rejected to
+     * verify whether it was successful.
+     *
+     * @param executable A command to run.
+     * @param args Arguments to launch the executable with. The arguments will be escaped such
+     * that they are interpreted as single arguments when the argument both contains whitespace
+     * and does not include any single quote, double quote or backtick characters.
+     *
+     * Note that this escaping is not intended to be a security measure, be careful when passing
+     * untrusted data to this API as strings like `$(...)` can often be used in shells to
+     * execute code within a string.
+     *
+     * @example
+     * // Execute a command in a terminal immediately after being created
+     * const myTerm = window.createTerminal();
+     * window.onDidChangeTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
+     *   if (terminal === myTerm) {
+     *     const command = shellIntegration.executeCommand({
+     *       command: 'echo',
+     *       args: ['Hello world']
+     *     });
+     *     const code = await command.exitCode;
+     *     console.log(`Command exited with code ${code}`);
+     *   }
+     * }));
+     * // Fallback to sendText if there is no shell integration within 3 seconds of launching
+     * setTimeout(() => {
+     *   if (!myTerm.shellIntegration) {
+     *     myTerm.sendText('echo "Hello world"');
+     *     // Without shell integration, we can't know when the command has finished or what the
+     *     // exit code was.
+     *   }
+     * }, 3000);
+     *
+     * @example
+     * // Send command to terminal that has been alive for a while
+     * const commandLine = 'echo "Hello world"';
+     * if (term.shellIntegration) {
+     *   const command = term.shellIntegration.executeCommand({
+     *     command: 'echo',
+     *     args: ['Hello world']
+     *   });
+     *   const code = await command.exitCode;
+     *   console.log(`Command exited with code ${code}`);
+     * } else {
+     *   term.sendText(commandLine);
+     *   // Without shell integration, we can't know when the command has finished or what the
+     *   // exit code was.
+     * }
+     */
+    executeCommand(executable: string, args: string[]): TerminalShellExecution;
+  }
+
+  /**
+   * A command that was executed in a terminal.
+   */
+  export interface TerminalShellExecution {
+    /**
+     * The command line that was executed. The {@link TerminalShellExecutionCommandLineConfidence confidence}
+     * of this value depends on the specific shell's shell integration implementation. This
+     * value may become more accurate after {@link window.onDidEndTerminalShellExecution} is
+     * fired.
+     *
+     * @example
+     * // Log the details of the command line on start and end
+     * window.onDidStartTerminalShellExecution(event => {
+     *   const commandLine = event.execution.commandLine;
+     *   console.log(`Command started\n${summarizeCommandLine(commandLine)}`);
+     * });
+     * window.onDidEndTerminalShellExecution(event => {
+     *   const commandLine = event.execution.commandLine;
+     *   console.log(`Command ended\n${summarizeCommandLine(commandLine)}`);
+     * });
+     * function summarizeCommandLine(commandLine: TerminalShellExecutionCommandLine) {
+     *   return [
+     *     `  Command line: ${command.commandLine.value}`,
+     *     `  Confidence: ${command.commandLine.confidence}`,
+     *     `  Trusted: ${command.commandLine.isTrusted}
+     *   ].join('\n');
+     * }
+     */
+    readonly commandLine: TerminalShellExecutionCommandLine;
+
+    /**
+     * The working directory that was reported by the shell when this command executed. This
+     * {@link Uri} may represent a file on another machine (eg. ssh into another machine). This
+     * requires the shell integration to support working directory reporting.
+     */
+    readonly cwd: Uri | undefined;
+
+    /**
+     * Creates a stream of raw data (including escape sequences) that is written to the
+     * terminal. This will only include data that was written after `read` was called for
+     * the first time, ie. you must call `read` immediately after the command is executed via
+     * {@link TerminalShellIntegration.executeCommand} or
+     * {@link window.onDidStartTerminalShellExecution} to not miss any data.
+     *
+     * @example
+     * // Log all data written to the terminal for a command
+     * const command = term.shellIntegration.executeCommand({ commandLine: 'echo "Hello world"' });
+     * const stream = command.read();
+     * for await (const data of stream) {
+     *   console.log(data);
+     * }
+     */
+    read(): AsyncIterable<string>;
+  }
+
+  /**
+   * A command line that was executed in a terminal.
+   */
+  export interface TerminalShellExecutionCommandLine {
+    /**
+     * The full command line that was executed, including both the command and its arguments.
+     */
+    readonly value: string;
+
+    /**
+     * Whether the command line value came from a trusted source and is therefore safe to
+     * execute without user additional confirmation, such as a notification that asks "Do you
+     * want to execute (command)?". This verification is likely only needed if you are going to
+     * execute the command again.
+     *
+     * This is `true` only when the command line was reported explicitly by the shell
+     * integration script (ie. {@link TerminalShellExecutionCommandLineConfidence.High high confidence})
+     * and it used a nonce for verification.
+     */
+    readonly isTrusted: boolean;
+
+    /**
+     * The confidence of the command line value which is determined by how the value was
+     * obtained. This depends upon the implementation of the shell integration script.
+     */
+    readonly confidence: TerminalShellExecutionCommandLineConfidence;
+  }
+
+  /**
+   * The confidence of a {@link TerminalShellExecutionCommandLine} value.
+   */
+  enum TerminalShellExecutionCommandLineConfidence {
+    /**
+     * The command line value confidence is low. This means that the value was read from the
+     * terminal buffer using markers reported by the shell integration script. Additionally one
+     * of the following conditions will be met:
+     *
+     * - The command started on the very left-most column which is unusual, or
+     * - The command is multi-line which is more difficult to accurately detect due to line
+     *   continuation characters and right prompts.
+     * - Command line markers were not reported by the shell integration script.
+     */
+    Low = 0,
+
+    /**
+     * The command line value confidence is medium. This means that the value was read from the
+     * terminal buffer using markers reported by the shell integration script. The command is
+     * single-line and does not start on the very left-most column (which is unusual).
+     */
+    Medium = 1,
+
+    /**
+     * The command line value confidence is high. This means that the value was explicitly sent
+     * from the shell integration script or the command was executed via the
+     * {@link TerminalShellIntegration.executeCommand} API.
+     */
+    High = 2
+  }
+
+  /**
+   * An event signalling that a terminal's shell integration has changed.
+   */
+  export interface TerminalShellIntegrationChangeEvent {
+    /**
+     * The terminal that shell integration has been activated in.
+     */
+    readonly terminal: Terminal;
+
+    /**
+     * The shell integration object.
+     */
+    readonly shellIntegration: TerminalShellIntegration;
+  }
+
+  /**
+   * An event signalling that an execution has started in a terminal.
+   */
+  export interface TerminalShellExecutionStartEvent {
+    /**
+     * The terminal that shell integration has been activated in.
+     */
+    readonly terminal: Terminal;
+
+    /**
+     * The shell integration object.
+     */
+    readonly shellIntegration: TerminalShellIntegration;
+
+    /**
+     * The terminal shell execution that has ended.
+     */
+    readonly execution: TerminalShellExecution;
+  }
+
+  /**
+   * An event signalling that an execution has ended in a terminal.
+   */
+  export interface TerminalShellExecutionEndEvent {
+    /**
+     * The terminal that shell integration has been activated in.
+     */
+    readonly terminal: Terminal;
+
+    /**
+     * The shell integration object.
+     */
+    readonly shellIntegration: TerminalShellIntegration;
+
+    /**
+     * The terminal shell execution that has ended.
+     */
+    readonly execution: TerminalShellExecution;
+
+    /**
+     * The exit code reported by the shell.
+     *
+     * Note that `undefined` means the shell either did not report an exit  code (ie. the shell
+     * integration script is misbehaving) or the shell reported a command started before the command
+     * finished (eg. a sub-shell was opened). Generally this should not happen, depending on the use
+     * case, it may be best to treat this as a failure.
+     *
+     * @example
+     * const execution = shellIntegration.executeCommand({
+     *   command: 'echo',
+     *   args: ['Hello world']
+     * });
+     * window.onDidEndTerminalShellExecution(event => {
+     *   if (event.execution === execution) {
+     *     if (event.exitCode === undefined) {
+     * 	     console.log('Command finished but exit code is unknown');
+     *     } else if (event.exitCode === 0) {
+     * 	     console.log('Command succeeded');
+     *     } else {
+     * 	     console.log('Command failed');
+     *     }
+     *   }
+     * });
+     */
+    readonly exitCode: number | undefined;
+  }
+
   //#region EnvironmentVariable
 
   /**
@@ -4114,26 +4587,46 @@ declare module 'vscode' {
   }
 
   /**
-	 * Provider which handles dropping of resources into a text editor.
-	 *
-	 * This allows users to drag and drop resources (including resources from external apps) into the editor. While dragging
-	 * and dropping files, users can hold down `shift` to drop the file into the editor instead of opening it.
-	 * Requires `editor.dropIntoEditor.enabled` to be on.
-	 */
-	export interface DocumentDropEditProvider {
-		/**
-		 * Provide edits which inserts the content being dragged and dropped into the document.
-		 *
-		 * @param document The document in which the drop occurred.
-		 * @param position The position in the document where the drop occurred.
-		 * @param dataTransfer A {@link DataTransfer} object that holds data about what is being dragged and dropped.
-		 * @param token A cancellation token.
-		 *
-		 * @returns A {@link DocumentDropEdit} or a thenable that resolves to such. The lack of a result can be
-		 * signaled by returning `undefined` or `null`.
-		 */
-		provideDocumentDropEdits(document: TextDocument, position: Position, dataTransfer: DataTransfer, token: CancellationToken): ProviderResult<DocumentDropEdit>;
-	}
+   * An edit operation applied {@link DocumentDropEditProvider on drop}.
+   */
+  export class DocumentDropEdit {
+    /**
+     * The text or snippet to insert at the drop location.
+     */
+    insertText: string | SnippetString;
+
+    /**
+     * An optional additional edit to apply on drop.
+     */
+    additionalEdit?: WorkspaceEdit;
+
+    /**
+     * @param insertText The text or snippet to insert at the drop location.
+     */
+    constructor(insertText: string | SnippetString);
+  }
+
+  /**
+   * Provider which handles dropping of resources into a text editor.
+   *
+   * This allows users to drag and drop resources (including resources from external apps) into the editor. While dragging
+   * and dropping files, users can hold down `shift` to drop the file into the editor instead of opening it.
+   * Requires `editor.dropIntoEditor.enabled` to be on.
+   */
+  export interface DocumentDropEditProvider {
+    /**
+     * Provide edits which inserts the content being dragged and dropped into the document.
+     *
+     * @param document The document in which the drop occurred.
+     * @param position The position in the document where the drop occurred.
+     * @param dataTransfer A {@link DataTransfer} object that holds data about what is being dragged and dropped.
+     * @param token A cancellation token.
+     *
+     * @returns A {@link DocumentDropEdit} or a thenable that resolves to such. The lack of a result can be
+     * signaled by returning `undefined` or `null`.
+     */
+    provideDocumentDropEdits(document: TextDocument, position: Position, dataTransfer: DataTransfer, token: CancellationToken): ProviderResult<DocumentDropEdit>;
+  }
 
   //#endregion Semantic Tokens
 

package/vscode/typings/vscode.debug.d.ts

@@ -564,6 +564,50 @@ declare module 'vscode' {
     Dynamic = 2
   }
 
+  /**
+   * Represents a thread in a debug session.
+   */
+  export class DebugThread {
+    /**
+     * Debug session for thread.
+     */
+    readonly session: DebugSession;
+
+    /**
+     * ID of the associated thread in the debug protocol.
+     */
+    readonly threadId: number;
+
+    /**
+     * @hidden
+     */
+    private constructor(session: DebugSession, threadId: number);
+  }
+
+  /**
+   * Represents a stack frame in a debug session.
+   */
+  export class DebugStackFrame {
+    /**
+     * Debug session for thread.
+     */
+    readonly session: DebugSession;
+
+    /**
+     * ID of the associated thread in the debug protocol.
+     */
+    readonly threadId: number;
+    /**
+     * ID of the stack frame in the debug protocol.
+     */
+    readonly frameId: number;
+
+    /**
+     * @hidden
+     */
+    private constructor(session: DebugSession, threadId: number, frameId: number);
+  }
+
   /**
    * A DebugProtocolSource is an opaque stand-in type for the [Source](https://microsoft.github.io/debug-adapter-protocol/specification#Types_Source) type defined in the Debug Adapter Protocol.
    */
@@ -767,6 +811,21 @@ declare module 'vscode' {
      */
     export const onDidChangeBreakpoints: Event<BreakpointsChangeEvent>;
 
+    /**
+     * The currently focused thread or stack frame, or `undefined` if no
+     * thread or stack is focused. A thread can be focused any time there is
+     * an active debug session, while a stack frame can only be focused when
+     * a session is paused and the call stack has been retrieved.
+     * @stubbed
+     */
+    export const activeStackItem: DebugThread | DebugStackFrame | undefined;
+
+    /**
+     * An event which fires when the {@link debug.activeStackItem} has changed.
+     * @stubbed
+     */
+    export const onDidChangeActiveStackItem: Event<DebugThread | DebugStackFrame | undefined>;
+
     /**
      * Register a [debug configuration provider](#DebugConfigurationProvider) for a specific debug type.
      * The optional [triggerKind](#DebugConfigurationProviderTriggerKind) can be used to specify when the `provideDebugConfigurations` method of the provider is triggered.

package/vscode/typings/vscode.editor.d.ts

@@ -123,7 +123,11 @@ declare module 'vscode' {
     /**
      * Render the line numbers with values relative to the primary cursor location.
      */
-    Relative = 2
+    Relative = 2,
+    /**
+     * Render the line numbers on every 10th line number.
+     */
+    Interval = 3
   }
 
   /**

package/vscode/typings/vscode.env.d.ts

@@ -69,6 +69,21 @@ declare module 'vscode' {
      */
     export const onDidChangeTelemetryEnabled: Event<boolean>;
 
+    /**
+     * An {@link Event} which fires when the default shell changes. This fires with the new
+     * shell path.
+     */
+    export const onDidChangeShell: Event<string>;
+
+    /**
+     * Creates a new {@link TelemetryLogger telemetry logger}.
+     *
+     * @param sender The telemetry sender that is used by the telemetry logger.
+     * @param options Options for the telemetry logger.
+     * @returns A new telemetry logger
+     */
+    export function createTelemetryLogger(sender: TelemetrySender, options?: TelemetryLoggerOptions): TelemetryLogger;
+
     /**
      * The name of a remote. Defined by extensions, popular samples are `wsl` for the Windows
      * Subsystem for Linux or `ssh-remote` for remotes using a secure shell.
@@ -89,7 +104,8 @@ declare module 'vscode' {
 
     /**
      * The detected default shell for the extension host, this is overridden by the
-     * `terminal.integrated.shell` setting for the extension host's platform.
+     * `terminal.integrated.defaultProfile` setting for the extension host's platform. Note that in
+     * environments that do not support a shell the value is the empty string.
      */
     export const shell: string;
 

package/vscode/typings/vscode.proposed.dropMetadata.d.ts

@@ -29,13 +29,6 @@ declare module 'vscode' {
 		 */
 		kind: DocumentPasteEditKind;
 
-		/**
-		 * The mime type from the {@link DataTransfer} that this edit applies.
-		 *
-		 * TODO: Should this be taken from `dropMimeTypes` instead?
-		 */
-		handledMimeType?: string;
-
 		/**
 		 * Controls the ordering or multiple paste edits. If this provider yield to edits, it will be shown lower in the list.
 		 */

package/vscode/typings/vscode.proposed.newSymbolNamesProvider.d.ts

@@ -11,6 +11,11 @@ declare module 'vscode' {
 		AIGenerated = 1
 	}
 
+	export enum NewSymbolNameTriggerKind {
+		Invoke = 0,
+		Automatic = 1,
+	}
+
 	export class NewSymbolName {
 		readonly newSymbolName: string;
 		readonly tags?: readonly NewSymbolNameTag[];
@@ -27,7 +32,7 @@ declare module 'vscode' {
 		 * @param token A cancellation token.
 		 * @return A list of new symbol names.
 		 */
-		provideNewSymbolNames(document: TextDocument, range: Range, token: CancellationToken): ProviderResult<NewSymbolName[]>;
+		provideNewSymbolNames(document: TextDocument, range: Range, triggerKind: NewSymbolNameTriggerKind, token: CancellationToken): ProviderResult<NewSymbolName[]>;
 	}
 
 	export namespace languages {

package/vscode/typings/vscode.tests.d.ts

@@ -78,6 +78,11 @@ declare module "vscode" {
      * user can configure this.
      */
     isDefault: boolean;
+    /**
+     * Fired when a user has changed whether this is a default profile. The
+     * event contains the new value of {@link isDefault}
+     */
+    onDidChangeDefault: Event<boolean>;
     /**
      * Whether this profile supports continuous running of requests. If so,
      * then {@link TestRunRequest.continuous} may be set to `true`. Defaults
@@ -117,6 +122,41 @@ declare module "vscode" {
       request: TestRunRequest,
       token: CancellationToken
     ) => Thenable<void> | void;
+
+    /**
+     * An extension-provided function that provides detailed statement and
+     * function-level coverage for a file. The editor will call this when more
+     * detail is needed for a file, such as when it's opened in an editor or
+     * expanded in the **Test Coverage** view.
+     *
+     * The {@link FileCoverage} object passed to this function is the same instance
+     * emitted on {@link TestRun.addCoverage} calls associated with this profile.
+     */
+    loadDetailedCoverage?: (testRun: TestRun, fileCoverage: FileCoverage, token: CancellationToken) => Thenable<FileCoverageDetail[]>;
+
+    /**
+     * An extension-provided function that provides detailed statement and
+     * function-level coverage for a single test in a file. This is the per-test
+     * sibling of {@link TestRunProfile.loadDetailedCoverage}, called only if
+     * a test item is provided in {@link FileCoverage.includesTests} and only
+     * for files where such data is reported.
+     *
+     * Often {@link TestRunProfile.loadDetailedCoverage} will be called first
+     * when a user opens a file, and then this method will be called if they
+     * drill down into specific per-test coverage information. This method
+     * should then return coverage data only for statements and declarations
+     * executed by the specific test during the run.
+     *
+     * The {@link FileCoverage} object passed to this function is the same
+     * instance emitted on {@link TestRun.addCoverage} calls associated with this profile.
+     *
+     * @param testRun The test run that generated the coverage data.
+     * @param fileCoverage The file coverage object to load detailed coverage for.
+     * @param fromTestItem The test item to request coverage information for.
+     * @param token A cancellation token that indicates the operation should be cancelled.
+     */
+    loadDetailedCoverageForTest?: (testRun: TestRun, fileCoverage: FileCoverage, fromTestItem: TestItem, token: CancellationToken) => Thenable<FileCoverageDetail[]>;
+
     /**
      * Deletes the run profile.
      */
@@ -305,6 +345,13 @@ declare module "vscode" {
      * relevant for profiles that set {@link TestRunProfile.supportsContinuousRun}.
      */
     readonly continuous?: boolean;
+    /**
+     * Controls how test Test Results view is focused.  If true, the editor
+     * will keep the maintain the user's focus. If false, the editor will
+     * prefer to move focus into the Test Results view, although
+     * this may be configured by users.
+    */
+    readonly preserveFocus?: boolean;
     /**
      * @param tests Array of specific tests to run, or undefined to run all tests
      * @param exclude An array of tests to exclude from the run.
@@ -410,12 +457,22 @@ declare module "vscode" {
      * @param test Test item to associate the output with.
      */
     appendOutput(output: string, location?: Location, test?: TestItem): void;
+    /**
+     * Adds coverage for a file in the run.
+     */
+    addCoverage(fileCoverage: FileCoverage): void;
     /**
      * Signals that the end of the test run. Any tests included in the run whose
      * states have not been updated will have their state reset.
      */
     end(): void;
+    /**
+     * An event fired when the editor is no longer interested in data
+     * associated with the test run.
+     */
+    onDidDispose: Event<void>;
   }
+
   /**
    * Collection of test items, found in {@link TestItem.children} and
    * {@link TestController.items}.
@@ -547,6 +604,33 @@ declare module "vscode" {
     // todo@api still unsure about this
     invalidateResults(): void;
   }
+  /**
+   * A stack frame found in the {@link TestMessage.stackTrace}.
+   */
+  export class TestMessageStackFrame {
+    /**
+     * The location of this stack frame. This should be provided as a URI if the
+     * location of the call frame can be accessed by the editor.
+     */
+    uri?: Uri;
+
+    /**
+     * Position of the stack frame within the file.
+     */
+    position?: Position;
+
+    /**
+     * The name of the stack frame, typically a method or function name.
+     */
+    label: string;
+
+    /**
+     * @param label The name of the stack frame
+     * @param file The file URI of the stack frame
+     * @param position The position of the stack frame within the file
+     */
+    constructor(label: string, uri?: Uri, position?: Position);
+  }
   /**
    * Message associated with the test state. Can be linked to a specific
    * source range -- useful for assertion failures, for example.
@@ -598,6 +682,10 @@ declare module "vscode" {
      * - `message`: the {@link TestMessage} instance.
      */
     contextValue?: string;
+    /**
+     * The stack trace associated with the message or failure.
+     */
+    stackTrace?: TestMessageStackFrame[];
     /**
      * Creates a new TestMessage that will present as a diff in the editor.
      * @param message Message to display to the user.
@@ -616,6 +704,27 @@ declare module "vscode" {
     constructor(message: string | MarkdownString);
   }
 
+  /**
+   * A class that contains information about a covered resource. A count can
+   * be give for lines, branches, and declarations in a file.
+   */
+  export class TestCoverageCount {
+    /**
+     * Number of items covered in the file.
+     */
+    covered: number;
+    /**
+     * Total number of covered items in the file.
+     */
+    total: number;
+
+    /**
+     * @param covered Value for {@link TestCoverageCount.covered}
+     * @param total Value for {@link TestCoverageCount.total}
+     */
+    constructor(covered: number, total: number);
+  }
+
   //#region Test Observer
 
   export interface TestObserver {
@@ -770,43 +879,6 @@ declare module "vscode" {
   }
   //#endregion
 
-  //#region Test Coverage
-
-  export interface TestRun {
-    /**
-     * Test coverage provider for this result. An extension can defer setting
-     * this until after a run is complete and coverage is available.
-     */
-    coverageProvider?: TestCoverageProvider
-    // ...
-  }
-
-  /**
-   * Provides information about test coverage for a test result.
-   * Methods on the provider will not be called until the test run is complete
-   */
-  export interface TestCoverageProvider<T extends FileCoverage = FileCoverage> {
-    /**
-     * Returns coverage information for all files involved in the test run.
-     * @param token A cancellation token.
-     * @return Coverage metadata for all files involved in the test.
-     */
-    provideFileCoverage(token: CancellationToken): ProviderResult<T[]>;
-
-    /**
-     * Give a FileCoverage to fill in more data, namely {@link FileCoverage.detailedCoverage}.
-     * The editor will only resolve a FileCoverage once, and onyl if detailedCoverage
-     * is undefined.
-     *
-     * @param coverage A coverage object obtained from {@link provideFileCoverage}
-     * @param token A cancellation token.
-     * @return The resolved file coverage, or a thenable that resolves to one. It
-     * is OK to return the given `coverage`. When no result is returned, the
-     * given `coverage` will be used.
-     */
-    resolveFileCoverage?(coverage: T, token: CancellationToken): ProviderResult<T>;
-  }
-
   /**
    * A class that contains information about a covered resource. A count can
    * be give for lines, branches, and functions in a file.
@@ -841,23 +913,25 @@ declare module "vscode" {
      * Statement coverage information. If the reporter does not provide statement
      * coverage information, this can instead be used to represent line coverage.
      */
-    statementCoverage: CoveredCount;
+    statementCoverage: TestCoverageCount;
 
     /**
      * Branch coverage information.
      */
-    branchCoverage?: CoveredCount;
+    branchCoverage?: TestCoverageCount;
 
     /**
-     * Function coverage information.
+     * Declaration coverage information. Depending on the reporter and
+     * language, this may be types such as functions, methods, or namespaces.
      */
-    functionCoverage?: CoveredCount;
+    declarationCoverage?: TestCoverageCount;
 
     /**
-     * Detailed, per-statement coverage. If this is undefined, the editor will
-     * call {@link TestCoverageProvider.resolveFileCoverage} when necessary.
+     * A list of {@link TestItem test cases} that generated coverage in this
+     * file. If set, then {@link TestRunProfile.loadDetailedCoverageForTest}
+     * should also be defined in order to retrieve detailed coverage information.
      */
-    detailedCoverage?: DetailedCoverage[];
+    includesTests?: TestItem[];
 
     /**
      * Creates a {@link FileCoverage} instance with counts filled in from
@@ -865,7 +939,7 @@ declare module "vscode" {
      * @param uri Covered file URI
      * @param detailed Detailed coverage information
      */
-    static fromDetails(uri: Uri, details: readonly DetailedCoverage[]): FileCoverage;
+    static fromDetails(uri: Uri, details: readonly FileCoverageDetail[]): FileCoverage;
 
     /**
      * @param uri Covered file URI
@@ -873,13 +947,15 @@ declare module "vscode" {
      * does not provide statement coverage information, this can instead be
      * used to represent line coverage.
      * @param branchCoverage Branch coverage information
-     * @param functionCoverage Function coverage information
+     * @param declarationCoverage Declaration coverage information
+     * @param includesTests Test cases included in this coverage report, see {@link includesTests}
      */
     constructor(
       uri: Uri,
-      statementCoverage: CoveredCount,
-      branchCoverage?: CoveredCount,
-      functionCoverage?: CoveredCount,
+      statementCoverage: TestCoverageCount,
+      branchCoverage?: TestCoverageCount,
+      declarationCoverage?: TestCoverageCount,
+      includesTests?: TestItem[],
     );
   }
 
@@ -888,10 +964,11 @@ declare module "vscode" {
    */
   export class StatementCoverage {
     /**
-     * The number of times this statement was executed. If zero, the
-     * statement will be marked as un-covered.
+     * The number of times this statement was executed, or a boolean indicating
+     * whether it was executed if the exact count is unknown. If zero or false,
+     * the statement will be marked as un-covered.
      */
-    executionCount: number;
+    executed: number | boolean;
 
     /**
      * Statement location.
@@ -906,12 +983,13 @@ declare module "vscode" {
 
     /**
      * @param location The statement position.
-     * @param executionCount The number of times this statement was
-     * executed. If zero, the statement will be marked as un-covered.
+     * @param executed The number of times this statement was executed, or a
+     * boolean indicating  whether it was executed if the exact count is
+     * unknown. If zero or false, the statement will be marked as un-covered.
      * @param branches Coverage from branches of this line.  If it's not a
      * conditional, this should be omitted.
      */
-    constructor(executionCount: number, location: Position | Range, branches?: BranchCoverage[]);
+    constructor(executed: number | boolean, location: Position | Range, branches?: BranchCoverage[]);
   }
 
   /**
@@ -919,10 +997,11 @@ declare module "vscode" {
    */
   export class BranchCoverage {
     /**
-     * The number of times this branch was executed. If zero, the
-     * branch will be marked as un-covered.
+     * The number of times this branch was executed, or a boolean indicating
+     * whether it was executed if the exact count is unknown. If zero or false,
+     * the branch will be marked as un-covered.
      */
-    executionCount: number;
+    executed: number | boolean;
 
     /**
      * Branch location.
@@ -930,12 +1009,56 @@ declare module "vscode" {
     location?: Position | Range;
 
     /**
-     * @param executionCount The number of times this branch was executed.
+     * Label for the branch, used in the context of "the ${label} branch was
+     * not taken," for example.
+     */
+    label?: string;
+
+    /**
+     * @param executed The number of times this branch was executed, or a
+     * boolean indicating  whether it was executed if the exact count is
+     * unknown. If zero or false, the branch will be marked as un-covered.
      * @param location The branch position.
      */
-    constructor(executionCount: number, location?: Position | Range);
+    constructor(executed: number | boolean, location?: Position | Range, label?: string);
   }
 
+  /**
+   * Contains coverage information for a declaration. Depending on the reporter
+   * and language, this may be types such as functions, methods, or namespaces.
+   */
+  export class DeclarationCoverage {
+    /**
+     * Name of the declaration.
+     */
+    name: string;
+
+    /**
+     * The number of times this declaration was executed, or a boolean
+     * indicating whether it was executed if the exact count is unknown. If
+     * zero or false, the declaration will be marked as un-covered.
+     */
+    executed: number | boolean;
+
+    /**
+     * Declaration location.
+     */
+    location: Position | Range;
+
+    /**
+     * @param executed The number of times this declaration was executed, or a
+     * boolean indicating  whether it was executed if the exact count is
+     * unknown. If zero or false, the declaration will be marked as un-covered.
+     * @param location The declaration position.
+     */
+    constructor(name: string, executed: number | boolean, location: Position | Range);
+  }
+
+  /**
+   * Coverage details returned from {@link TestRunProfile.loadDetailedCoverage}.
+   */
+  export type FileCoverageDetail = StatementCoverage | DeclarationCoverage;
+
   /**
    * Contains coverage information for a function or method.
    */

package/vscode/typings/vscode.window.d.ts

@@ -420,6 +420,25 @@ declare module 'vscode' {
      */
     export const onDidChangeTerminalState: Event<Terminal>;
 
+    /**
+     * Fires when shell integration activates or one of its properties changes in a terminal.
+     */
+    export const onDidChangeTerminalShellIntegration: Event<TerminalShellIntegrationChangeEvent>;
+
+    /**
+     * This will be fired when a terminal command is started. This event will fire only when
+     * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
+     * activated for the terminal.
+     */
+    export const onDidStartTerminalShellExecution: Event<TerminalShellExecutionStartEvent>;
+
+    /**
+     * This will be fired when a terminal command is ended. This event will fire only when
+     * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
+     * activated for the terminal.
+     */
+    export const onDidEndTerminalShellExecution: Event<TerminalShellExecutionEndEvent>;
+
     /**
      * Represents the current window's state.
      */
@@ -869,6 +888,12 @@ declare module 'vscode' {
      */
     readonly visible: boolean;
 
+    /**
+     * The badge to display for this webview view.
+     * To remove the badge, set to undefined.
+     */
+    badge?: ViewBadge | undefined;
+
     /**
      * Event fired when the visibility of the view changes.
      *