@opensumi/sumi 2.20.10 → 2.21.0

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

@@ -942,6 +942,11 @@ declare module 'sumi-worker' {
      * array containing all selected tree items.
      */
     canSelectMany?: boolean;
+
+    /**
+     * An optional interface to implement drag and drop in the tree view.
+     */
+    dragAndDropController?: TreeDragAndDropController<T>;
   }
 
   /**
@@ -974,6 +979,167 @@ declare module 'sumi-worker' {
     readonly visible: boolean;
   }
 
+  /**
+   * 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
    */

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

@@ -216,6 +216,19 @@ declare module 'sumi-worker' {
      */
     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.
      *
@@ -2172,6 +2185,159 @@ declare module 'sumi-worker' {
     readonly uris: ReadonlyArray<Uri>;
   }
 
+  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>;
+  }
+
   /**
    * A diagnostics collection is a container that manages a set of
    * [diagnostics](#Diagnostic). Diagnostics are always scopes to a

package/vscode/typings/vscode.command.d.ts

@@ -1,86 +1,86 @@
 declare module 'vscode' {
-	/**
-	 * Represents a reference to a command. Provides a title which
-	 * will be used to represent a command in the UI and, optionally,
-	 * an array of arguments which will be passed to the command handler
-	 * function when invoked.
-	 */
-	export interface Command {
-		/**
-		 * Title of the command, like `save`.
-		 */
-		title: string;
+  /**
+   * Represents a reference to a command. Provides a title which
+   * will be used to represent a command in the UI and, optionally,
+   * an array of arguments which will be passed to the command handler
+   * function when invoked.
+   */
+  export interface Command {
+    /**
+     * Title of the command, like `save`.
+     */
+    title: string;
 
-		/**
-		 * The identifier of the actual command handler.
-		 * @see [commands.registerCommand](#commands.registerCommand).
-		 */
-		command: string;
+    /**
+     * The identifier of the actual command handler.
+     * @see [commands.registerCommand](#commands.registerCommand).
+     */
+    command: string;
 
-		/**
-		 * A tooltip for the command, when represented in the UI.
-		 */
-		tooltip?: string;
+    /**
+     * A tooltip for the command, when represented in the UI.
+     */
+    tooltip?: string;
 
-		/**
-		 * Arguments that the command handler should be
-		 * invoked with.
-		 */
-		arguments?: any[];
-	}
+    /**
+     * Arguments that the command handler should be
+     * invoked with.
+     */
+    arguments?: any[];
+  }
   export namespace commands {
     /**
-		 * Registers a command that can be invoked via a keyboard shortcut,
-		 * a menu item, an action, or directly.
-		 *
-		 * Registering a command with an existing command identifier twice
-		 * will cause an error.
-		 *
-		 * @param command A unique identifier for the command.
-		 * @param callback A command handler function.
-		 * @param thisArg The `this` context used when invoking the handler function.
-		 * @return Disposable which unregisters this command on disposal.
-		 */
-		export function registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): Disposable;
+     * Registers a command that can be invoked via a keyboard shortcut,
+     * a menu item, an action, or directly.
+     *
+     * Registering a command with an existing command identifier twice
+     * will cause an error.
+     *
+     * @param command A unique identifier for the command.
+     * @param callback A command handler function.
+     * @param thisArg The `this` context used when invoking the handler function.
+     * @return Disposable which unregisters this command on disposal.
+     */
+    export function registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): Disposable;
 
-		/**
-		 * Executes the command denoted by the given command identifier.
-		 *
-		 * * *Note 1:* When executing an editor command not all types are allowed to
-		 * be passed as arguments. Allowed are the primitive types `string`, `boolean`,
-		 * `number`, `undefined`, and `null`, as well as [`Position`](#Position), [`Range`](#Range), [`Uri`](#Uri) and [`Location`](#Location).
-		 * * *Note 2:* There are no restrictions when executing commands that have been contributed
-		 * by extensions.
-		 *
-		 * @param command Identifier of the command to execute.
-		 * @param rest Parameters passed to the command function.
-		 * @return A thenable that resolves to the returned value of the given command. `undefined` when
-		 * the command handler function doesn't return anything.
-		 */
-		export function executeCommand<T>(command: string, ...rest: any[]): Thenable<T | undefined>;
+    /**
+     * Executes the command denoted by the given command identifier.
+     *
+     * * *Note 1:* When executing an editor command not all types are allowed to
+     * be passed as arguments. Allowed are the primitive types `string`, `boolean`,
+     * `number`, `undefined`, and `null`, as well as [`Position`](#Position), [`Range`](#Range), [`Uri`](#Uri) and [`Location`](#Location).
+     * * *Note 2:* There are no restrictions when executing commands that have been contributed
+     * by extensions.
+     *
+     * @param command Identifier of the command to execute.
+     * @param rest Parameters passed to the command function.
+     * @return A thenable that resolves to the returned value of the given command. `undefined` when
+     * the command handler function doesn't return anything.
+     */
+    export function executeCommand<T>(command: string, ...rest: any[]): Thenable<T | undefined>;
 
-		/**
-		 * Retrieve the list of all available commands. Commands starting an underscore are
-		 * treated as internal commands.
-		 *
-		 * @param filterInternal Set `true` to not see internal commands (starting with an underscore)
-		 * @return Thenable that resolves to a list of command ids.
-		 */
-		export function getCommands(filterInternal?: boolean): Thenable<string[]>;
-			/**
-		 * Registers a text editor command that can be invoked via a keyboard shortcut,
-		 * a menu item, an action, or directly.
-		 *
-		 * Text editor commands are different from ordinary [commands](#commands.registerCommand) as
-		 * they only execute when there is an active editor when the command is called. Also, the
-		 * command handler of an editor command has access to the active editor and to an
-		 * [edit](#TextEditorEdit)-builder.
-		 *
-		 * @param command A unique identifier for the command.
-		 * @param callback A command handler function with access to an [editor](#TextEditor) and an [edit](#TextEditorEdit).
-		 * @param thisArg The `this` context used when invoking the handler function.
-		 * @return Disposable which unregisters this command on disposal.
-		 */
-		export function registerTextEditorCommand(command: string, callback: (textEditor: TextEditor, edit: TextEditorEdit, ...args: any[]) => void, thisArg?: any): Disposable;
-	}
+    /**
+     * Retrieve the list of all available commands. Commands starting an underscore are
+     * treated as internal commands.
+     *
+     * @param filterInternal Set `true` to not see internal commands (starting with an underscore)
+     * @return Thenable that resolves to a list of command ids.
+     */
+    export function getCommands(filterInternal?: boolean): Thenable<string[]>;
+      /**
+     * Registers a text editor command that can be invoked via a keyboard shortcut,
+     * a menu item, an action, or directly.
+     *
+     * Text editor commands are different from ordinary [commands](#commands.registerCommand) as
+     * they only execute when there is an active editor when the command is called. Also, the
+     * command handler of an editor command has access to the active editor and to an
+     * [edit](#TextEditorEdit)-builder.
+     *
+     * @param command A unique identifier for the command.
+     * @param callback A command handler function with access to an [editor](#TextEditor) and an [edit](#TextEditorEdit).
+     * @param thisArg The `this` context used when invoking the handler function.
+     * @return Disposable which unregisters this command on disposal.
+     */
+    export function registerTextEditorCommand(command: string, callback: (textEditor: TextEditor, edit: TextEditorEdit, ...args: any[]) => void, thisArg?: any): Disposable;
+  }
 }

package/vscode/typings/vscode.comments.d.ts

@@ -201,6 +201,12 @@ declare module 'vscode' {
      * Label will be rendered next to authorName if exists.
      */
     label?: string;
+
+    /**
+     * Optional timestamp that will be displayed in comments.
+     * The date will be formatted according to the user's locale and settings.
+     */
+    timestamp?: Date;
   }
 
   /**