@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/platform/layout/browser/layoutService.service.d.ts

@@ -5,25 +5,76 @@ import { ILayoutOffsetInfo } from "./layoutService.js";
 export declare const ILayoutService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ILayoutService>;
 export interface ILayoutService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event that is emitted when the main container is layed out.
+    */
     readonly onDidLayoutMainContainer: Event<IDimension>;
+    /**
+    * An event that is emitted when any container is layed out.
+    */
     readonly onDidLayoutContainer: Event<{
         readonly container: HTMLElement;
         readonly dimension: IDimension;
     }>;
+    /**
+    * An event that is emitted when the active container is layed out.
+    */
     readonly onDidLayoutActiveContainer: Event<IDimension>;
+    /**
+    * An event that is emitted when a new container is added. This
+    * can happen in multi-window environments.
+    */
     readonly onDidAddContainer: Event<{
         readonly container: HTMLElement;
         readonly disposables: DisposableStore;
     }>;
+    /**
+    * An event that is emitted when the active container changes.
+    */
     readonly onDidChangeActiveContainer: Event<void>;
+    /**
+    * The dimensions of the main container.
+    */
     readonly mainContainerDimension: IDimension;
+    /**
+    * The dimensions of the active container.
+    */
     readonly activeContainerDimension: IDimension;
+    /**
+    * Main container of the application.
+    */
     readonly mainContainer: HTMLElement;
+    /**
+    * Active container of the application. When multiple windows are opened, will return
+    * the container of the active, focused window.
+    */
     readonly activeContainer: HTMLElement;
+    /**
+    * All the containers of the application. There can be one container per window.
+    */
     readonly containers: Iterable<HTMLElement>;
+    /**
+    * Get the container for the given window.
+    */
     getContainer(window: Window): HTMLElement;
+    /**
+    * Ensures that the styles for the container associated
+    * to the window have loaded. For the main window, this
+    * will resolve instantly, but for floating windows, this
+    * will resolve once the styles have been loaded and helps
+    * for when certain layout assumptions are made.
+    */
     whenContainerStylesLoaded(window: Window): Promise<void> | undefined;
+    /**
+    * An offset to use for positioning elements inside the main container.
+    */
     readonly mainContainerOffset: ILayoutOffsetInfo;
+    /**
+    * An offset to use for positioning elements inside the container.
+    */
     readonly activeContainerOffset: ILayoutOffsetInfo;
+    /**
+    * Focus the primary component of the active container.
+    */
     focus(): void;
 }

package/vscode/src/vs/platform/list/browser/listService.service.d.ts

@@ -2,5 +2,8 @@ import { WorkbenchListWidget } from "./listService.js";
 export declare const IListService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IListService>;
 export interface IListService {
     readonly _serviceBrand: undefined;
+    /**
+    * Returns the currently focused list widget if any.
+    */
     readonly lastFocusedList: WorkbenchListWidget | undefined;
 }

package/vscode/src/vs/platform/log/common/log.d.ts

@@ -24,6 +24,9 @@ export interface ILogger extends IDisposable {
     info(message: string, ...args: any[]): void;
     warn(message: string, ...args: any[]): void;
     error(message: string | Error, ...args: any[]): void;
+    /**
+     * An operation to flush the contents. Can be synchronous.
+     */
     flush(): void;
 }
 export declare function canLog(loggerLevel: LogLevel, messageLevel: LogLevel): boolean;
@@ -33,14 +36,41 @@ export type LoggerGroup = {
     readonly name: string;
 };
 export interface ILoggerOptions {
+    /**
+     * Id of the logger.
+     */
     id?: string;
+    /**
+     * Name of the logger.
+     */
     name?: string;
+    /**
+     * Do not create rotating files if max size exceeds.
+     */
     donotRotate?: boolean;
+    /**
+     * Do not use formatters.
+     */
     donotUseFormatters?: boolean;
+    /**
+     * When to log. Set to `always` to log always.
+     */
     logLevel?: "always" | LogLevel;
+    /**
+     * Whether the log should be hidden from the user.
+     */
     hidden?: boolean;
+    /**
+     * Condition which must be true to show this logger
+     */
     when?: string;
+    /**
+     * Id of the extension that created this logger.
+     */
     extensionId?: string;
+    /**
+     * Group of the logger.
+     */
     group?: LoggerGroup;
 }
 export interface ILoggerResource {

package/vscode/src/vs/platform/log/common/log.service.d.ts

@@ -8,24 +8,76 @@ export interface ILogService extends ILogger {
 export declare const ILoggerService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ILoggerService>;
 export interface ILoggerService {
     readonly _serviceBrand: undefined;
+    /**
+    * Creates a logger for the given resource, or gets one if it already exists.
+    *
+    * This will also register the logger with the logger service.
+    */
     createLogger(resource: URI, options?: ILoggerOptions): ILogger;
+    /**
+    * Creates a logger with the given id in the logs folder, or gets one if it already exists.
+    *
+    * This will also register the logger with the logger service.
+    */
     createLogger(id: string, options?: Omit<ILoggerOptions, "id">): ILogger;
+    /**
+    * Gets an existing logger, if any.
+    */
     getLogger(resourceOrId: URI | string): ILogger | undefined;
+    /**
+    * An event which fires when the log level of a logger has changed
+    */
     readonly onDidChangeLogLevel: Event<LogLevel | [
         URI,
         LogLevel
     ]>;
+    /**
+    * Set default log level.
+    */
     setLogLevel(level: LogLevel): void;
+    /**
+    * Set log level for a logger.
+    */
     setLogLevel(resource: URI, level: LogLevel): void;
+    /**
+    * Get log level for a logger or the default log level.
+    */
     getLogLevel(resource?: URI): LogLevel;
+    /**
+    * An event which fires when the visibility of a logger has changed
+    */
     readonly onDidChangeVisibility: Event<[
         URI,
         boolean
     ]>;
+    /**
+    * Set the visibility of a logger.
+    */
     setVisibility(resourceOrId: URI | string, visible: boolean): void;
+    /**
+    * An event which fires when the logger resources are changed
+    */
     readonly onDidChangeLoggers: Event<DidChangeLoggersEvent>;
+    /**
+    * Register a logger with the logger service.
+    *
+    * Note that this will not create a logger, but only register it.
+    *
+    * Use `createLogger` to create a logger and register it.
+    *
+    * Use it when you want to register a logger that is not created by the logger service.
+    */
     registerLogger(resource: ILoggerResource): void;
+    /**
+    * Deregister the logger for the given resource.
+    */
     deregisterLogger(idOrResource: URI | string): void;
+    /**
+    * Get all registered loggers
+    */
     getRegisteredLoggers(): Iterable<ILoggerResource>;
+    /**
+    * Get the registered logger for the given resource.
+    */
     getRegisteredLogger(resource: URI): ILoggerResource | undefined;
 }

package/vscode/src/vs/platform/markers/common/markerService.d.ts

@@ -17,6 +17,9 @@ export declare class MarkerService implements IMarkerService {
     installResourceFilter(resource: URI, reason: string): IDisposable;
     private static _toMarker;
     changeAll(owner: string, data: IResourceMarker[]): void;
+    /**
+     * Creates an information marker for filtered resources
+     */
     private _createFilteredMarker;
     read(filter?: IMarkerReadOptions): IMarker[];
     private static _accept;

package/vscode/src/vs/platform/markers/common/markers.d.ts

@@ -7,6 +7,9 @@ export interface IMarkerReadOptions {
     take?: number;
     ignoreResourceFilters?: boolean;
 }
+/**
+ *
+ */
 export interface IRelatedInformation {
     resource: URI;
     message: string;
@@ -32,6 +35,9 @@ export declare namespace MarkerSeverity {
     function fromSeverity(severity: Severity): MarkerSeverity;
     function toSeverity(severity: MarkerSeverity): Severity;
 }
+/**
+ * A structure defining a problem/warning/etc.
+ */
 export interface IMarkerData {
     code?: string | {
         value: string;

package/vscode/src/vs/platform/notification/common/notification.d.ts

@@ -4,87 +4,272 @@ import Severity from "../../../base/common/severity.js";
 export { Severity };
 export type NotificationMessage = string | Error;
 export declare enum NotificationPriority {
+    /**
+     * Default priority: notification will be visible unless do not disturb mode is enabled.
+     */
     DEFAULT = 0,
+    /**
+     * Optional priority: notification might only be visible from the notifications center.
+     */
     OPTIONAL = 1,
+    /**
+     * Silent priority: notification will only be visible from the notifications center.
+     */
     SILENT = 2,
+    /**
+     * Urgent priority: notification will be visible even when do not disturb mode is enabled.
+     */
     URGENT = 3
 }
 export interface INotificationProperties {
+    /**
+     * Sticky notifications are not automatically removed after a certain timeout.
+     *
+     * Currently, only 2 kinds of notifications are sticky:
+     * - Error notifications with primary actions
+     * - Notifications that show progress
+     */
     readonly sticky?: boolean;
+    /**
+     * Allows to override the priority of the notification based on needs.
+     */
     readonly priority?: NotificationPriority;
+    /**
+     * Adds an action to never show the notification again. The choice will be persisted
+     * such as future requests will not cause the notification to show again.
+     */
     readonly neverShowAgain?: INeverShowAgainOptions;
 }
 export declare enum NeverShowAgainScope {
+    /**
+     * Will never show this notification on the current workspace again.
+     */
     WORKSPACE = 0,
+    /**
+     * Will never show this notification on any workspace of the same
+     * profile again.
+     */
     PROFILE = 1,
+    /**
+     * Will never show this notification on any workspace across all
+     * profiles again.
+     */
     APPLICATION = 2
 }
 export interface INeverShowAgainOptions {
+    /**
+     * The id is used to persist the selection of not showing the notification again.
+     */
     readonly id: string;
+    /**
+     * By default the action will show up as primary action. Setting this to true will
+     * make it a secondary action instead.
+     */
     readonly isSecondary?: boolean;
+    /**
+     * Whether to persist the choice in the current workspace or for all workspaces. By
+     * default it will be persisted for all workspaces across all profiles
+     * (= `NeverShowAgainScope.APPLICATION`).
+     */
     readonly scope?: NeverShowAgainScope;
 }
 export interface INotificationSource {
+    /**
+     * The id of the source.
+     */
     readonly id: string;
+    /**
+     * The label of the source.
+     */
     readonly label: string;
 }
 export declare function isNotificationSource(thing: unknown): thing is INotificationSource;
 export interface INotification extends INotificationProperties {
+    /**
+     * The id of the notification. If provided, will be used to compare
+     * notifications with others to decide whether a notification is
+     * duplicate or not.
+     */
     readonly id?: string;
+    /**
+     * The severity of the notification. Either `Info`, `Warning` or `Error`.
+     */
     readonly severity: Severity;
+    /**
+     * The message of the notification. This can either be a `string` or `Error`. Messages
+     * can optionally include links in the format: `[text](link)`
+     */
     readonly message: NotificationMessage;
+    /**
+     * The source of the notification appears as additional information.
+     */
     readonly source?: string | INotificationSource;
+    /**
+     * Actions to show as part of the notification. Primary actions show up as
+     * buttons as part of the message and will close the notification once clicked.
+     *
+     * Secondary actions are meant to provide additional configuration or context
+     * for the notification and will show up less prominent. A notification does not
+     * close automatically when invoking a secondary action.
+     *
+     * **Note:** If your intent is to show a message with actions to the user, consider
+     * the `INotificationService.prompt()` method instead which are optimized for
+     * this usecase and much easier to use!
+     */
     actions?: INotificationActions;
+    /**
+     * The initial set of progress properties for the notification. To update progress
+     * later on, access the `INotificationHandle.progress` property.
+     */
     readonly progress?: INotificationProgressProperties;
 }
 export interface INotificationActions {
+    /**
+     * Primary actions show up as buttons as part of the message and will close
+     * the notification once clicked.
+     *
+     * Pass `ActionWithMenuAction` for an action that has additional menu actions.
+     */
     readonly primary?: readonly IAction[];
+    /**
+     * Secondary actions are meant to provide additional configuration or context
+     * for the notification and will show up less prominent. A notification does not
+     * close automatically when invoking a secondary action.
+     */
     readonly secondary?: readonly IAction[];
 }
 export interface INotificationProgressProperties {
+    /**
+     * Causes the progress bar to spin infinitley.
+     */
     readonly infinite?: boolean;
+    /**
+     * Indicate the total amount of work.
+     */
     readonly total?: number;
+    /**
+     * Indicate that a specific chunk of work is done.
+     */
     readonly worked?: number;
 }
 export interface INotificationProgress {
+    /**
+     * Causes the progress bar to spin infinitley.
+     */
     infinite(): void;
+    /**
+     * Indicate the total amount of work.
+     */
     total(value: number): void;
+    /**
+     * Indicate that a specific chunk of work is done.
+     */
     worked(value: number): void;
+    /**
+     * Indicate that the long running operation is done.
+     */
     done(): void;
 }
 export interface INotificationHandle {
+    /**
+     * Will be fired once the notification is closed.
+     */
     readonly onDidClose: Event<void>;
+    /**
+     * Will be fired whenever the visibility of the notification changes.
+     * A notification can either be visible as toast or inside the notification
+     * center if it is visible.
+     */
     readonly onDidChangeVisibility: Event<boolean>;
+    /**
+     * Allows to indicate progress on the notification even after the
+     * notification is already visible.
+     */
     readonly progress: INotificationProgress;
+    /**
+     * Allows to update the severity of the notification.
+     */
     updateSeverity(severity: Severity): void;
+    /**
+     * Allows to update the message of the notification even after the
+     * notification is already visible.
+     */
     updateMessage(message: NotificationMessage): void;
+    /**
+     * Allows to update the actions of the notification even after the
+     * notification is already visible.
+     */
     updateActions(actions?: INotificationActions): void;
+    /**
+     * Hide the notification and remove it from the notification center.
+     */
     close(): void;
 }
 export interface IStatusHandle {
+    /**
+     * Hide the status message.
+     */
     close(): void;
 }
 interface IBasePromptChoice {
+    /**
+     * Label to show for the choice to the user.
+     */
     readonly label: string;
+    /**
+     * Whether to keep the notification open after the choice was selected
+     * by the user. By default, will close the notification upon click.
+     */
     readonly keepOpen?: boolean;
+    /**
+     * Triggered when the user selects the choice.
+     */
     run: () => void;
 }
 export interface IPromptChoice extends IBasePromptChoice {
+    /**
+     * Primary choices show up as buttons in the notification below the message.
+     * Secondary choices show up under the gear icon in the header of the notification.
+     */
     readonly isSecondary?: boolean;
 }
 export interface IPromptChoiceWithMenu extends IPromptChoice {
+    /**
+     * Additional choices those will be shown in the dropdown menu for this choice.
+     */
     readonly menu: IBasePromptChoice[];
+    /**
+     * Menu is not supported on secondary choices
+     */
     readonly isSecondary: false | undefined;
 }
 export interface IPromptOptions extends INotificationProperties {
+    /**
+     * Will be called if the user closed the notification without picking
+     * any of the provided choices.
+     */
     onCancel?: () => void;
 }
 export interface IStatusMessageOptions {
+    /**
+     * An optional timeout after which the status message should show. By default
+     * the status message will show immediately.
+     */
     readonly showAfter?: number;
+    /**
+     * An optional timeout after which the status message is to be hidden. By default
+     * the status message will not hide until another status message is displayed.
+     */
     readonly hideAfter?: number;
 }
 export declare enum NotificationsFilter {
+    /**
+     * No filter is enabled.
+     */
     OFF = 0,
+    /**
+     * All notifications are silent except error notifications.
+    */
     ERROR = 1
 }
 export interface INotificationSourceFilter extends INotificationSource {

package/vscode/src/vs/platform/notification/common/notification.service.d.ts

@@ -2,17 +2,80 @@ import { Event } from "../../../base/common/event.js";
 import Severity from "../../../base/common/severity.js";
 import { NotificationsFilter, INotificationSourceFilter, INotificationSource, INotification, INotificationHandle, NotificationMessage, IPromptChoice, IPromptChoiceWithMenu, IPromptOptions, IStatusMessageOptions, IStatusHandle } from "./notification.js";
 export declare const INotificationService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<INotificationService>;
+/**
+* A service to bring up notifications and non-modal prompts.
+*
+* Note: use the `IDialogService` for a modal way to ask the user for input.
+*/
 export interface INotificationService {
     readonly _serviceBrand: undefined;
+    /**
+    * Emitted when the notifications filter changed.
+    */
     readonly onDidChangeFilter: Event<void>;
+    /**
+    * Sets a notification filter either for all notifications
+    * or for a specific source.
+    */
     setFilter(filter: NotificationsFilter | INotificationSourceFilter): void;
+    /**
+    * Gets the notification filter either for all notifications
+    * or for a specific source.
+    */
     getFilter(source?: INotificationSource): NotificationsFilter;
+    /**
+    * Returns all filters with their sources.
+    */
     getFilters(): INotificationSourceFilter[];
+    /**
+    * Removes a filter for a specific source.
+    */
     removeFilter(sourceId: string): void;
+    /**
+    * Show the provided notification to the user. The returned `INotificationHandle`
+    * can be used to control the notification afterwards.
+    *
+    * **Note:** If your intent is to show a message with actions to the user, consider
+    * the `INotificationService.prompt()` method instead which are optimized for
+    * this usecase and much easier to use!
+    *
+    * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
+    */
     notify(notification: INotification): INotificationHandle;
+    /**
+    * A convenient way of reporting infos. Use the `INotificationService.notify`
+    * method if you need more control over the notification.
+    */
     info(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+    * A convenient way of reporting warnings. Use the `INotificationService.notify`
+    * method if you need more control over the notification.
+    */
     warn(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+    * A convenient way of reporting errors. Use the `INotificationService.notify`
+    * method if you need more control over the notification.
+    */
     error(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+    * Shows a prompt in the notification area with the provided choices. The prompt
+    * is non-modal. If you want to show a modal dialog instead, use `IDialogService`.
+    *
+    * @param severity the severity of the notification. Either `Info`, `Warning` or `Error`.
+    * @param message the message to show as status.
+    * @param choices options to be chosen from.
+    * @param options provides some optional configuration options.
+    *
+    * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
+    */
     prompt(severity: Severity, message: string, choices: (IPromptChoice | IPromptChoiceWithMenu)[], options?: IPromptOptions): INotificationHandle;
+    /**
+    * Shows a status message in the status area with the provided text.
+    *
+    * @param message the message to show as status
+    * @param options provides some optional configuration options
+    *
+    * @returns a handle to hide the status message
+    */
     status(message: NotificationMessage, options?: IStatusMessageOptions): IStatusHandle;
 }

package/vscode/src/vs/platform/observable/common/platformObservableUtils.d.ts

@@ -3,6 +3,8 @@ import { IObservable, IReader } from "../../../base/common/observable.js";
 import { IConfigurationService } from "../../configuration/common/configuration.service.js";
 import { ContextKeyValue, RawContextKey } from "../../contextkey/common/contextkey.js";
 import { IContextKeyService } from "../../contextkey/common/contextkey.service.js";
+/** Creates an observable update when a configuration key updates. */
 export declare function observableConfigValue<T>(key: string, defaultValue: T, configurationService: IConfigurationService): IObservable<T>;
+/** Update the configuration key with a value derived from observables. */
 export declare function bindContextKey<T extends ContextKeyValue>(key: RawContextKey<T>, service: IContextKeyService, computeValue: (reader: IReader) => T): IDisposable;
 export declare function observableContextKey<T>(key: string, contextKeyService: IContextKeyService): IObservable<T | undefined>;

package/vscode/src/vs/platform/observable/common/wrapInHotClass.d.ts

@@ -2,8 +2,18 @@ import { IDisposable } from "../../../base/common/lifecycle.js";
 import { IObservable } from "../../../base/common/observable.js";
 import { BrandedService } from "../../instantiation/common/instantiation.js";
 export declare function hotClassGetOriginalInstance<T>(value: T): T;
+/**
+ * Wrap a class in a reloadable wrapper.
+ * When the wrapper is created, the original class is created.
+ * When the original class changes, the instance is re-created.
+*/
 export declare function wrapInHotClass0<TArgs extends BrandedService[]>(clazz: IObservable<Result<TArgs>>): Result<TArgs>;
 type Result<TArgs extends any[]> = new (...args: TArgs) => IDisposable;
+/**
+ * Wrap a class in a reloadable wrapper.
+ * When the wrapper is created, the original class is created.
+ * When the original class changes, the instance is re-created.
+*/
 export declare function wrapInHotClass1<TArgs extends [
     any,
     ...BrandedService[]

package/vscode/src/vs/platform/observable/common/wrapInReloadableClass.d.ts

@@ -1,7 +1,17 @@
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import { BrandedService, GetLeadingNonServiceArgs } from "../../instantiation/common/instantiation.js";
+/**
+ * Wrap a class in a reloadable wrapper.
+ * When the wrapper is created, the original class is created.
+ * When the original class changes, the instance is re-created.
+*/
 export declare function wrapInReloadableClass0<TArgs extends BrandedService[]>(getClass: () => Result<TArgs>): Result<TArgs>;
 type Result<TArgs extends any[]> = new (...args: TArgs) => IDisposable;
+/**
+ * Wrap a class in a reloadable wrapper.
+ * When the wrapper is created, the original class is created.
+ * When the original class changes, the instance is re-created.
+*/
 export declare function wrapInReloadableClass1<TArgs extends [
     any,
     ...BrandedService[]

package/vscode/src/vs/platform/opener/browser/link.css

@@ -1,6 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-link {
 	color: var(--vscode-textLink-foreground);
 }
+
 .monaco-link:hover {
 	color: var(--vscode-textLink-activeForeground);
 }
+