@opensumi/sumi 2.20.10 → 2.21.0

package/vscode/typings/vscode.d.ts

@@ -411,6 +411,72 @@ declare module 'vscode' {
     constructor(options: TerminalOptions | ExtensionTerminalOptions);
   }
 
+
+  /**
+   * A file decoration represents metadata that can be rendered with a file.
+   */
+  export class FileDecoration {
+
+    /**
+     * A very short string that represents this decoration.
+     */
+    badge?: string;
+
+    /**
+     * A human-readable tooltip for this decoration.
+     */
+    tooltip?: string;
+
+    /**
+     * The color of this decoration.
+     */
+    color?: ThemeColor;
+
+    /**
+     * A flag expressing that this decoration should be
+     * propagated to its parents.
+     */
+    propagate?: boolean;
+
+    /**
+     * Creates a new decoration.
+     *
+     * @param badge A letter that represents the decoration.
+     * @param tooltip The tooltip of the decoration.
+     * @param color The color of the decoration.
+     */
+    constructor(badge?: string, tooltip?: string, color?: ThemeColor);
+  }
+
+  /**
+   * The decoration provider interfaces defines the contract between extensions and
+   * file decorations.
+   */
+  export interface FileDecorationProvider {
+
+    /**
+     * An optional event to signal that decorations for one or many files have changed.
+     *
+     * *Note* that this event should be used to propagate information about children.
+     *
+     * @see {@link EventEmitter}
+     */
+    onDidChangeFileDecorations?: Event<undefined | Uri | Uri[]>;
+
+    /**
+     * Provide decorations for a given uri.
+     *
+     * *Note* that this function is only called when a file gets rendered in the UI.
+     * This means a decoration from a descendent that propagates upwards must be signaled
+     * to the editor via the {@link FileDecorationProvider.onDidChangeFileDecorations onDidChangeFileDecorations}-event.
+     *
+     * @param uri The uri of the file to provide a decoration for.
+     * @param token A cancellation token.
+     * @returns A decoration or a thenable that resolves to such.
+     */
+    provideFileDecoration(uri: Uri, token: CancellationToken): ProviderResult<FileDecoration>;
+  }
+
   /**
    * Class used to execute an extension callback as a task.
    */
@@ -1462,6 +1528,11 @@ declare module 'vscode' {
      * array containing all selected tree items.
      */
     canSelectMany?: boolean;
+
+    /**
+		* An optional interface to implement drag and drop in the tree view.
+		*/
+		dragAndDropController?: TreeDragAndDropController<T>;
   }
 
   /**
@@ -1500,6 +1571,166 @@ declare module 'vscode' {
 
   }
 
+
+	/**
+	 * A file associated with a {@linkcode DataTransferItem}.
+	 */
+	export interface DataTransferFile {
+		/**
+		 * The name of the file.
+		 */
+		readonly name: string;
+
+		/**
+		 * The full file path of the file.
+		 *
+		 * May be `undefined` on web.
+		 */
+		readonly uri?: Uri;
+
+		/**
+		 * The full file contents of the file.
+		 */
+		data(): Thenable<Uint8Array>;
+	}
+
+	/**
+	 * Encapsulates data transferred during drag and drop operations.
+	 */
+	export class DataTransferItem {
+		/**
+		 * Get a string representation of this item.
+		 *
+		 * If {@linkcode DataTransferItem.value} is an object, this returns the result of json stringifying {@linkcode DataTransferItem.value} value.
+		 */
+		asString(): Thenable<string>;
+
+		/**
+		 * Try getting the {@link DataTransferFile file} associated with this data transfer item.
+		 *
+		 * Note that the file object is only valid for the scope of the drag and drop operation.
+		 *
+		 * @returns The file for the data transfer or `undefined` if the item is either not a file or the
+		 * file data cannot be accessed.
+		 */
+		asFile(): DataTransferFile | undefined;
+
+		/**
+		 * Custom data stored on this item.
+		 *
+		 * You can use `value` to share data across operations. The original object can be retrieved so long as the extension that
+		 * created the `DataTransferItem` runs in the same extension host.
+		 */
+		readonly value: any;
+
+		/**
+		 * @param value Custom data stored on this item. Can be retrieved using {@linkcode DataTransferItem.value}.
+		 */
+		constructor(value: any);
+	}
+
+	/**
+	 * A map containing a mapping of the mime type of the corresponding transferred data.
+	 *
+	 * Drag and drop controllers that implement {@link TreeDragAndDropController.handleDrag `handleDrag`} can add additional mime types to the
+	 * data transfer. These additional mime types will only be included in the `handleDrop` when the the drag was initiated from
+	 * an element in the same drag and drop controller.
+	 */
+	export class DataTransfer implements Iterable<[mimeType: string, item: DataTransferItem]> {
+		/**
+		 * Retrieves the data transfer item for a given mime type.
+		 *
+		 * @param mimeType The mime type to get the data transfer item for, such as `text/plain` or `image/png`.
+		 *
+		 * Special mime types:
+		 * - `text/uri-list` — A string with `toString()`ed Uris separated by `\r\n`. To specify a cursor position in the file,
+		 * set the Uri's fragment to `L3,5`, where 3 is the line number and 5 is the column number.
+		 */
+		get(mimeType: string): DataTransferItem | undefined;
+
+		/**
+		 * Sets a mime type to data transfer item mapping.
+		 * @param mimeType The mime type to set the data for.
+		 * @param value The data transfer item for the given mime type.
+		 */
+		set(mimeType: string, value: DataTransferItem): void;
+
+		/**
+		 * Allows iteration through the data transfer items.
+		 *
+		 * @param callbackfn Callback for iteration through the data transfer items.
+		 * @param thisArg The `this` context used when invoking the handler function.
+		 */
+		forEach(callbackfn: (item: DataTransferItem, mimeType: string, dataTransfer: DataTransfer) => void, thisArg?: any): void;
+
+		/**
+		 * Get a new iterator with the `[mime, item]` pairs for each element in this data transfer.
+		 */
+		[Symbol.iterator](): IterableIterator<[mimeType: string, item: DataTransferItem]>;
+	}
+
+	/**
+	 * Provides support for drag and drop in `TreeView`.
+	 */
+	export interface TreeDragAndDropController<T> {
+
+		/**
+		 * The mime types that the {@link TreeDragAndDropController.handleDrop `handleDrop`} method of this `DragAndDropController` supports.
+		 * This could be well-defined, existing, mime types, and also mime types defined by the extension.
+		 *
+		 * To support drops from trees, you will need to add the mime type of that tree.
+		 * This includes drops from within the same tree.
+		 * The mime type of a tree is recommended to be of the format `application/vnd.code.tree.<treeidlowercase>`.
+		 *
+		 * Use the special `files` mime type to support all types of dropped files {@link DataTransferFile files}, regardless of the file's actual mime type.
+		 *
+		 * To learn the mime type of a dragged item:
+		 * 1. Set up your `DragAndDropController`
+		 * 2. Use the Developer: Set Log Level... command to set the level to "Debug"
+		 * 3. Open the developer tools and drag the item with unknown mime type over your tree. The mime types will be logged to the developer console
+		 *
+		 * Note that mime types that cannot be sent to the extension will be omitted.
+		 */
+		readonly dropMimeTypes: readonly string[];
+
+		/**
+		 * The mime types that the {@link TreeDragAndDropController.handleDrag `handleDrag`} method of this `TreeDragAndDropController` may add to the tree data transfer.
+		 * This could be well-defined, existing, mime types, and also mime types defined by the extension.
+		 *
+		 * The recommended mime type of the tree (`application/vnd.code.tree.<treeidlowercase>`) will be automatically added.
+		 */
+		readonly dragMimeTypes: readonly string[];
+
+		/**
+		 * When the user starts dragging items from this `DragAndDropController`, `handleDrag` will be called.
+		 * Extensions can use `handleDrag` to add their {@link DataTransferItem `DataTransferItem`} items to the drag and drop.
+		 *
+		 * When the items are dropped on **another tree item** in **the same tree**, your `DataTransferItem` objects
+		 * will be preserved. Use the recommended mime type for the tree (`application/vnd.code.tree.<treeidlowercase>`) to add
+		 * tree objects in a data transfer. See the documentation for `DataTransferItem` for how best to take advantage of this.
+		 *
+		 * To add a data transfer item that can be dragged into the editor, use the application specific mime type "text/uri-list".
+		 * The data for "text/uri-list" should be a string with `toString()`ed Uris separated by newlines. To specify a cursor position in the file,
+		 * set the Uri's fragment to `L3,5`, where 3 is the line number and 5 is the column number.
+		 *
+		 * @param source The source items for the drag and drop operation.
+		 * @param dataTransfer The data transfer associated with this drag.
+		 * @param token A cancellation token indicating that drag has been cancelled.
+		 */
+		handleDrag?(source: readonly T[], dataTransfer: DataTransfer, token: CancellationToken): Thenable<void> | void;
+
+		/**
+		 * Called when a drag and drop action results in a drop on the tree that this `DragAndDropController` belongs to.
+		 *
+		 * Extensions should fire {@link TreeDataProvider.onDidChangeTreeData onDidChangeTreeData} for any elements that need to be refreshed.
+		 *
+		 * @param dataTransfer The data transfer items of the source of the drag.
+		 * @param target The target tree element that the drop is occurring on. When undefined, the target is the root.
+		 * @param token A cancellation token indicating that the drop has been cancelled.
+		 */
+		handleDrop?(target: T | undefined, dataTransfer: DataTransfer, token: CancellationToken): Thenable<void> | void;
+	}
+
   /**
    * Represents a Tree view
    */
@@ -1568,6 +1799,24 @@ declare module 'vscode' {
     reveal(element: T, options?: { select?: boolean, focus?: boolean, expand?: boolean | number }): Thenable<void>;
   }
 
+  /**
+   * Label describing the [Tree item](#TreeItem)
+   */
+  export interface TreeItemLabel {
+
+    /**
+     * A human-readable string describing the [Tree item](#TreeItem).
+     */
+    label: string;
+
+    /**
+     * Ranges in the label to highlight. A range is defined as a tuple of two number where the
+     * first is the inclusive start index and the second the exclusive end index
+     */
+    highlights?: [number, number][];
+
+  }
+
   /**
  * Collapsible state of the tree item
  */
@@ -2580,6 +2829,21 @@ declare module 'vscode' {
     onDidChange: Event<SecretStorageChangeEvent>;
   }
 
+  /**
+   * Represents the dimensions of a terminal.
+   */
+  export interface TerminalDimensions {
+    /**
+     * The number of columns in the terminal.
+     */
+    readonly columns: number;
+
+    /**
+     * The number of rows in the terminal.
+     */
+    readonly rows: number;
+  }
+
   /**
    * Represents how a terminal exited.
    */
@@ -2607,9 +2871,9 @@ declare module 'vscode' {
     readonly processId: Thenable<number>;
 
     /**
-		 * The current state of the {@link Terminal}.
-		 */
-		readonly state: TerminalState;
+     * The current state of the {@link Terminal}.
+     */
+    readonly state: TerminalState;
 
     /**
      * The object used to initialize the terminal, this is useful for example to detecting the

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

@@ -528,7 +528,7 @@ declare module 'vscode' {
    */
   export enum DebugConfigurationProviderTriggerKind {
     /**
-     *	`DebugConfigurationProvider.provideDebugConfigurations` is called to provide the initial debug configurations for a newly created launch.json.
+     *  `DebugConfigurationProvider.provideDebugConfigurations` is called to provide the initial debug configurations for a newly created launch.json.
      */
     Initial = 1,
     /**

package/vscode/typings/vscode.doc.d.ts

@@ -1,7 +1,3 @@
-/**
- * API OWENR: 木农
- */
-
 declare module 'vscode' {
   /**
 	 * Represents a text document, such as a source file. Text documents have

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

@@ -10,20 +10,20 @@ declare module 'vscode' {
     export const appName: string;
 
     /**
-		 * The application root folder from which the editor is running.
-		 *
-		 * *Note* that the value is the empty string when running in an
-		 * environment that has no representation of an application root folder.
-		 */
+     * The application root folder from which the editor is running.
+     *
+     * *Note* that the value is the empty string when running in an
+     * environment that has no representation of an application root folder.
+     */
     export const appRoot: string;
 
     /**
-		 * The hosted location of the application
-		 * On desktop this is 'desktop'
-		 * In the web this is the specified embedder i.e. 'github.dev', 'codespaces', or 'web' if the embedder
-		 * does not provide that information
-		 */
-		export const appHost: string;
+     * The hosted location of the application
+     * On desktop this is 'desktop'
+     * In the web this is the specified embedder i.e. 'github.dev', 'codespaces', or 'web' if the embedder
+     * does not provide that information
+     */
+    export const appHost: string;
 
     /**
      * The custom uri scheme the editor registers to in the operating system.
@@ -52,21 +52,21 @@ declare module 'vscode' {
     export const sessionId: string;
 
     /**
-		 * Indicates that this is a fresh install of the application.
-		 * `true` if within the first day of installation otherwise `false`.
-		 */
+     * Indicates that this is a fresh install of the application.
+     * `true` if within the first day of installation otherwise `false`.
+     */
     export const isNewAppInstall: boolean;
 
     /**
-		 * Indicates whether the users has telemetry enabled.
-		 * Can be observed to determine if the extension should send telemetry.
-		 */
+     * Indicates whether the users has telemetry enabled.
+     * Can be observed to determine if the extension should send telemetry.
+     */
     export const isTelemetryEnabled: boolean;
 
     /**
-		 * An [event](#Event) which fires when the user enabled or disables telemetry.
-		 * `true` if the user has enabled telemetry or `false` if the user has disabled telemetry.
-		 */
+     * An [event](#Event) which fires when the user enabled or disables telemetry.
+     * `true` if the user has enabled telemetry or `false` if the user has disabled telemetry.
+     */
     export const onDidChangeTelemetryEnabled: Event<boolean>;
 
     /**

package/vscode/typings/vscode.language.d.ts

@@ -222,6 +222,19 @@ declare module 'vscode' {
       */
     export function registerColorProvider(selector: DocumentSelector, provider: DocumentColorProvider): Disposable;
 
+    /**
+     * Register a inlay hints provider.
+     *
+     * Multiple providers can be registered for a language. In that case providers are asked in
+     * parallel and the results are merged. A failing provider (rejected promise or exception) will
+     * not cause a failure of the whole operation.
+     *
+     * @param selector A selector that defines the documents this provider is applicable to.
+     * @param provider An inlay hints provider.
+     * @return A {@link Disposable} that unregisters this provider when being disposed.
+     */
+    export function registerInlayHintsProvider(selector: DocumentSelector, provider: InlayHintsProvider): Disposable;
+
     /**
      * Register a folding range provider.
      *
@@ -483,6 +496,163 @@ declare module 'vscode' {
     export function registerEvaluatableExpressionProvider(selector: DocumentSelector, provider: EvaluatableExpressionProvider): Disposable;
   }
 
+
+  export enum InlayHintKind {
+    Type = 1,
+    Parameter = 2,
+  }
+
+  /**
+   * An inlay hint label part allows for interactive and composite labels of inlay hints.
+   */
+  export class InlayHintLabelPart {
+
+    /**
+     * The value of this label part.
+     */
+    value: string;
+
+    /**
+     * The tooltip text when you hover over this label part.
+     *
+     * *Note* that this property can be set late during
+     * {@link InlayHintsProvider.resolveInlayHint resolving} of inlay hints.
+     */
+    tooltip?: string | MarkdownString | undefined;
+
+    /**
+     * An optional {@link Location source code location} that represents this label
+     * part.
+     *
+     * The editor will use this location for the hover and for code navigation features: This
+     * part will become a clickable link that resolves to the definition of the symbol at the
+     * given location (not necessarily the location itself), it shows the hover that shows at
+     * the given location, and it shows a context menu with further code navigation commands.
+     *
+     * *Note* that this property can be set late during
+     * {@link InlayHintsProvider.resolveInlayHint resolving} of inlay hints.
+     */
+    location?: Location | undefined;
+
+    /**
+     * An optional command for this label part.
+     *
+     * The editor renders parts with commands as clickable links. The command is added to the context menu
+     * when a label part defines {@link InlayHintLabelPart.location location} and {@link InlayHintLabelPart.command command} .
+     *
+     * *Note* that this property can be set late during
+     * {@link InlayHintsProvider.resolveInlayHint resolving} of inlay hints.
+     */
+    command?: Command | undefined;
+
+    /**
+     * Creates a new inlay hint label part.
+     *
+     * @param value The value of the part.
+     */
+    constructor(value: string);
+  }
+
+  /**
+   * Inlay hint information.
+   */
+   export class InlayHint {
+
+    /**
+     * The position of this hint.
+     */
+    position: Position;
+
+    /**
+     * The label of this hint. A human readable string or an array of {@link InlayHintLabelPart label parts}.
+     *
+     * *Note* that neither the string nor the label part can be empty.
+     */
+    label: string | InlayHintLabelPart[];
+
+    /**
+     * The tooltip text when you hover over this item.
+     *
+     * *Note* that this property can be set late during
+     * {@link InlayHintsProvider.resolveInlayHint resolving} of inlay hints.
+     */
+    tooltip?: string | MarkdownString | undefined;
+
+    /**
+     * The kind of this hint. The inlay hint kind defines the appearance of this inlay hint.
+     */
+    kind?: InlayHintKind;
+
+    /**
+     * Optional {@link TextEdit text edits} that are performed when accepting this inlay hint. The default
+     * gesture for accepting an inlay hint is the double click.
+     *
+     * *Note* that edits are expected to change the document so that the inlay hint (or its nearest variant) is
+     * now part of the document and the inlay hint itself is now obsolete.
+     *
+     * *Note* that this property can be set late during
+     * {@link InlayHintsProvider.resolveInlayHint resolving} of inlay hints.
+     */
+    textEdits?: TextEdit[];
+
+    /**
+     * Render padding before the hint. Padding will use the editor's background color,
+     * not the background color of the hint itself. That means padding can be used to visually
+     * align/separate an inlay hint.
+     */
+    paddingLeft?: boolean;
+
+    /**
+     * Render padding after the hint. Padding will use the editor's background color,
+     * not the background color of the hint itself. That means padding can be used to visually
+     * align/separate an inlay hint.
+     */
+    paddingRight?: boolean;
+
+    /**
+     * Creates a new inlay hint.
+     *
+     * @param position The position of the hint.
+     * @param label The label of the hint.
+     * @param kind The {@link InlayHintKind kind} of the hint.
+     */
+    constructor(position: Position, label: string | InlayHintLabelPart[], kind?: InlayHintKind);
+  }
+
+  /**
+   * The inlay hints provider interface defines the contract between extensions and
+   * the inlay hints feature.
+   */
+  export interface InlayHintsProvider<T extends InlayHint = InlayHint> {
+
+    /**
+     * An optional event to signal that inlay hints have changed.
+     * @see {@link EventEmitter}
+     */
+    onDidChangeInlayHints?: Event<void>;
+
+    /**
+     *
+     * @param model The document in which the command was invoked.
+     * @param range The range for which inlay hints should be computed.
+     * @param token A cancellation token.
+     * @return A list of inlay hints or a thenable that resolves to such.
+     */
+    provideInlayHints(model: TextDocument, range: Range, token: CancellationToken): ProviderResult<T[]>;
+
+    /**
+     * Given an inlay hint fill in {@link InlayHint.tooltip tooltip}, {@link InlayHint.textEdits text edits},
+     * or complete label {@link InlayHintLabelPart parts}.
+     *
+     * *Note* that the editor will resolve an inlay hint at most once.
+     *
+     * @param hint An inlay hint.
+     * @param token A cancellation token.
+     * @return The resolved inlay hint or a thenable that resolves to such. It is OK to return the given `item`. When no result is returned, the given `item` will be used.
+     */
+    resolveInlayHint?(hint: T, token: CancellationToken): ProviderResult<T>;
+  }
+
   /**
    * Represents a list of ranges that can be edited together along with a word pattern to describe valid range contents.
    */

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

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+   // https://github.com/microsoft/vscode/issues/88309
+
+  /**
+   * An {@link Event} which fires when an {@link AuthenticationProvider} is added or removed.
+   */
+  export interface AuthenticationProvidersChangeEvent {
+    /**
+     * The ids of the {@link AuthenticationProvider}s that have been added.
+     */
+    readonly added: ReadonlyArray<AuthenticationProviderInformation>;
+
+    /**
+     * The ids of the {@link AuthenticationProvider}s that have been removed.
+     */
+    readonly removed: ReadonlyArray<AuthenticationProviderInformation>;
+  }
+
+  export namespace authentication {
+    /**
+     * @deprecated - getSession should now trigger extension activation.
+     * Fires with the provider id that was registered or unregistered.
+     */
+    export const onDidChangeAuthenticationProviders: Event<AuthenticationProvidersChangeEvent>;
+
+    /**
+     * @deprecated
+     * An array of the information of authentication providers that are currently registered.
+     */
+    export const providers: ReadonlyArray<AuthenticationProviderInformation>;
+
+    /**
+     * @deprecated
+     * Logout of a specific session.
+     * @param providerId The id of the provider to use
+     * @param sessionId The session id to remove
+     * provider
+     */
+    export function logout(providerId: string, sessionId: string): Thenable<void>;
+  }
+}

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

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+  // https://github.com/microsoft/vscode/issues/84899
+
+  /**
+   * The contiguous set of modified lines in a diff.
+   */
+  export interface LineChange {
+    readonly originalStartLineNumber: number;
+    readonly originalEndLineNumber: number;
+    readonly modifiedStartLineNumber: number;
+    readonly modifiedEndLineNumber: number;
+  }
+
+  export namespace commands {
+
+    /**
+     * Registers a diff information command that can be invoked via a keyboard shortcut,
+     * a menu item, an action, or directly.
+     *
+     * Diff information commands are different from ordinary {@link commands.registerCommand commands} as
+     * they only execute when there is an active diff editor when the command is called, and the diff
+     * information has been computed. Also, the command handler of an editor command has access to
+     * the diff information.
+     *
+     * @param command A unique identifier for the command.
+     * @param callback A command handler function with access to the {@link LineChange diff information}.
+     * @param thisArg The `this` context used when invoking the handler function.
+     * @return Disposable which unregisters this command on disposal.
+     */
+    export function registerDiffInformationCommand(command: string, callback: (diff: LineChange[], ...args: any[]) => any, thisArg?: any): Disposable;
+  }
+}