@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/workbench/services/extensions/common/extensions.service.d.ts

@@ -6,33 +6,127 @@ import { IExtensionPoint } from "./extensionsRegistry.js";
 export declare const IExtensionService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtensionService>;
 export interface IExtensionService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event emitted when extensions are registered after their extension points got handled.
+    *
+    * This event will also fire on startup to signal the installed extensions.
+    *
+    * @returns the extensions that got registered
+    */
     onDidRegisterExtensions: Event<void>;
+    /**
+    * @event
+    * Fired when extensions status changes.
+    * The event contains the ids of the extensions that have changed.
+    */
     onDidChangeExtensionsStatus: Event<ExtensionIdentifier[]>;
+    /**
+    * Fired when the available extensions change (i.e. when extensions are added or removed).
+    */
     onDidChangeExtensions: Event<{
         readonly added: readonly IExtensionDescription[];
         readonly removed: readonly IExtensionDescription[];
     }>;
+    /**
+    * All registered extensions.
+    * - List will be empty initially during workbench startup and will be filled with extensions as they are registered
+    * - Listen to `onDidChangeExtensions` event for any changes to the extensions list. It will change as extensions get registered or de-reigstered.
+    * - Listen to `onDidRegisterExtensions` event or wait for `whenInstalledExtensionsRegistered` promise to get the initial list of registered extensions.
+    */
     readonly extensions: readonly IExtensionDescription[];
+    /**
+    * An event that is fired when activation happens.
+    */
     onWillActivateByEvent: Event<IWillActivateEvent>;
+    /**
+    * An event that is fired when an extension host changes its
+    * responsive-state.
+    */
     onDidChangeResponsiveChange: Event<IResponsiveStateChangeEvent>;
+    /**
+    * Fired before stop of extension hosts happens. Allows listeners to veto against the
+    * stop to prevent it from happening.
+    */
     onWillStop: Event<WillStopExtensionHostsEvent>;
+    /**
+    * Send an activation event and activate interested extensions.
+    *
+    * This will wait for the normal startup of the extension host(s).
+    *
+    * In extraordinary circumstances, if the activation event needs to activate
+    * one or more extensions before the normal startup is finished, then you can use
+    * `ActivationKind.Immediate`. Please do not use this flag unless really necessary
+    * and you understand all consequences.
+    */
     activateByEvent(activationEvent: string, activationKind?: ActivationKind): Promise<void>;
+    /**
+    * Send an activation ID and activate interested extensions.
+    *
+    */
     activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    /**
+    * Determine if `activateByEvent(activationEvent)` has resolved already.
+    *
+    * i.e. the activation event is finished and all interested extensions are already active.
+    */
     activationEventIsDone(activationEvent: string): boolean;
+    /**
+    * An promise that resolves when the installed extensions are registered after
+    * their extension points got handled.
+    */
     whenInstalledExtensionsRegistered(): Promise<boolean>;
+    /**
+    * Return a specific extension
+    * @param id An extension id
+    */
     getExtension(id: string): Promise<IExtensionDescription | undefined>;
+    /**
+    * Returns `true` if the given extension can be added. Otherwise `false`.
+    * @param extension An extension
+    */
     canAddExtension(extension: IExtensionDescription): boolean;
+    /**
+    * Returns `true` if the given extension can be removed. Otherwise `false`.
+    * @param extension An extension
+    */
     canRemoveExtension(extension: IExtensionDescription): boolean;
+    /**
+    * Read all contributions to an extension point.
+    */
     readExtensionPointContributions<T extends IExtensionContributions[keyof IExtensionContributions]>(extPoint: IExtensionPoint<T>): Promise<ExtensionPointContribution<T>[]>;
+    /**
+    * Get information about extensions status.
+    */
     getExtensionsStatus(): {
         [id: string]: IExtensionsStatus;
     };
+    /**
+    * Return the inspect ports (if inspection is possible) for extension hosts of kind `extensionHostKind`.
+    */
     getInspectPorts(extensionHostKind: ExtensionHostKind, tryEnableInspector: boolean): Promise<IExtensionInspectInfo[]>;
+    /**
+    * Stops the extension hosts.
+    *
+    * @param reason a human readable reason for stopping the extension hosts. This maybe
+    * can be presented to the user when showing dialogs.
+    *
+    * @param auto indicates if the operation was triggered by an automatic action
+    *
+    * @returns a promise that resolves to `true` if the extension hosts were stopped, `false`
+    * if the operation was vetoed by listeners of the `onWillStop` event.
+    */
     stopExtensionHosts(reason: string, auto?: boolean): Promise<boolean>;
+    /**
+    * Starts the extension hosts. If updates are provided, the extension hosts are started with the given updates.
+    */
     startExtensionHosts(updates?: {
         readonly toAdd: readonly IExtension[];
         readonly toRemove: readonly string[];
     }): Promise<void>;
+    /**
+    * Modify the environment of the remote extension host
+    * @param env New properties for the remote extension host
+    */
     setRemoteEnvironment(env: {
         [key: string]: string | null;
     }): Promise<void>;

package/vscode/src/vs/workbench/services/extensions/common/extensionsRegistry.d.ts

@@ -53,6 +53,10 @@ export interface IExtensionPointDescriptor<T> {
     jsonSchema: IJSONSchema;
     defaultExtensionKind?: ExtensionKind[];
     canHandleResolver?: boolean;
+    /**
+     * A function which runs before the extension point has been validated and which
+     * should collect automatic activation events from the contribution.
+     */
     activationEventsGenerator?: IActivationEventsGenerator<removeArray<T>>;
 }
 export declare class ExtensionsRegistryImpl {

package/vscode/src/vs/workbench/services/extensions/common/proxyIdentifier.d.ts

@@ -1,9 +1,21 @@
 import type { VSBuffer } from "../../../../base/common/buffer.js";
 import type { CancellationToken } from "../../../../base/common/cancellation.js";
 export interface IRPCProtocol {
+    /**
+     * Returns a proxy to an object addressable/named in the extension host process or in the renderer process.
+     */
     getProxy<T>(identifier: ProxyIdentifier<T>): Proxied<T>;
+    /**
+     * Register manually created instance.
+     */
     set<T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R;
+    /**
+     * Assert these identifiers are already registered via `.set`.
+     */
     assertRegistered(identifiers: ProxyIdentifier<any>[]): void;
+    /**
+     * Wait for the write buffer (if applicable) to become empty.
+     */
     drain(): Promise<void>;
     dispose(): void;
 }
@@ -15,6 +27,9 @@ export declare class ProxyIdentifier<T> {
     constructor(sid: string);
 }
 export declare function createProxyIdentifier<T>(identifier: string): ProxyIdentifier<T>;
+/**
+ * Mapped-type that replaces all JSONable-types with their toJSON-result type
+ */
 export type Dto<T> = T extends {
     toJSON(): infer U;
 } ? U : T extends VSBuffer ? T : T extends CancellationToken ? T : T extends Function ? never : T extends object ? {
@@ -26,6 +41,9 @@ export type Proxied<T> = {
     }) => Promise<Dto<Awaited<R>>> : never;
 };
 export declare function getStringIdentifierForProxy(nid: number): string;
+/**
+ * Marks the object as containing buffers that should be serialized more efficiently.
+ */
 export declare class SerializableObjectWithBuffers<T> {
     readonly value: T;
     constructor(value: T);

package/vscode/src/vs/workbench/services/files/common/elevatedFileService.service.d.ts

@@ -4,6 +4,13 @@ import { IWriteFileOptions, IFileStatWithMetadata } from "../../../../platform/f
 export declare const IElevatedFileService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IElevatedFileService>;
 export interface IElevatedFileService {
     readonly _serviceBrand: undefined;
+    /**
+    * Whether saving elevated is supported for the provided resource.
+    */
     isSupported(resource: URI): boolean;
+    /**
+    * Attempts to write to the target resource elevated. This may bring
+    * up a dialog to ask for admin username / password.
+    */
     writeFileElevated(resource: URI, value: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;
 }

package/vscode/src/vs/workbench/services/history/common/history.d.ts

@@ -1,10 +1,38 @@
+/**
+ * Limit editor navigation to certain kinds.
+ */
 export declare enum GoFilter {
+    /**
+     * Navigate between editor navigation history
+     * entries from any kind of navigation source.
+     */
     NONE = 0,
+    /**
+     * Only navigate between editor navigation history
+     * entries that were resulting from edits.
+     */
     EDITS = 1,
+    /**
+     * Only navigate between editor navigation history
+     * entries that were resulting from navigations, such
+     * as "Go to definition".
+     */
     NAVIGATION = 2
 }
+/**
+ * Limit editor navigation to certain scopes.
+ */
 export declare enum GoScope {
+    /**
+     * Navigate across all editors and editor groups.
+     */
     DEFAULT = 0,
+    /**
+     * Navigate only in editors of the active editor group.
+     */
     EDITOR_GROUP = 1,
+    /**
+     * Navigate only in the active editor.
+     */
     EDITOR = 2
 }

package/vscode/src/vs/workbench/services/history/common/history.service.d.ts

@@ -6,17 +6,68 @@ import { GoFilter } from "./history.js";
 export declare const IHistoryService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IHistoryService>;
 export interface IHistoryService {
     readonly _serviceBrand: undefined;
+    /**
+    * Navigate forwards in editor navigation history.
+    */
     goForward(filter?: GoFilter): Promise<void>;
+    /**
+    * Navigate backwards in editor navigation history.
+    */
     goBack(filter?: GoFilter): Promise<void>;
+    /**
+    * Navigate between the current editor navigtion history entry
+    * and the previous one that was navigated to. This commands is
+    * like a toggle for `forward` and `back` to jump between 2 points
+    * in editor navigation history.
+    */
     goPrevious(filter?: GoFilter): Promise<void>;
+    /**
+    * Navigate to the last entry in editor navigation history.
+    */
     goLast(filter?: GoFilter): Promise<void>;
+    /**
+    * Re-opens the last closed editor if any.
+    */
     reopenLastClosedEditor(): Promise<void>;
+    /**
+    * Get the entire history of editors that were opened.
+    */
     getHistory(): readonly (EditorInput | IResourceEditorInput)[];
+    /**
+    * Removes an entry from history.
+    */
     removeFromHistory(input: EditorInput | IResourceEditorInput): void;
+    /**
+    * Looking at the editor history, returns the workspace root of the last file that was
+    * inside the workspace and part of the editor history.
+    *
+    * @param schemeFilter filter to restrict roots by scheme.
+    */
     getLastActiveWorkspaceRoot(schemeFilter?: string, authorityFilter?: string): URI | undefined;
+    /**
+    * Looking at the editor history, returns the resource of the last file that was opened.
+    *
+    * @param schemeFilter filter to restrict roots by scheme.
+    */
     getLastActiveFile(schemeFilter: string, authorityFilter?: string): URI | undefined;
+    /**
+    * Opens the next used editor if any.
+    *
+    * @param group optional indicator to scope to a specific group.
+    */
     openNextRecentlyUsedEditor(group?: GroupIdentifier): Promise<void>;
+    /**
+    * Opens the previously used editor if any.
+    *
+    * @param group optional indicator to scope to a specific group.
+    */
     openPreviouslyUsedEditor(group?: GroupIdentifier): Promise<void>;
+    /**
+    * Clears all history.
+    */
     clear(): void;
+    /**
+    * Clear list of recently opened editors.
+    */
     clearRecentlyOpened(): void;
 }

package/vscode/src/vs/workbench/services/host/browser/host.service.d.ts

@@ -3,33 +3,102 @@ import { Event } from "../../../../base/common/event.js";
 import { FocusMode } from "@codingame/monaco-vscode-fc42f049-7883-579d-bb0b-2aa1010a19a8-common/vscode/vs/platform/native/common/native";
 import { IOpenEmptyWindowOptions, IWindowOpenable, IOpenWindowOptions, IPoint, IRectangle } from "../../../../platform/window/common/window.js";
 export declare const IHostService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IHostService>;
+/**
+* A set of methods supported in both web and native environments.
+*
+* @see {@link INativeHostService} for methods that are specific to native
+* environments.
+*/
 export interface IHostService {
     readonly _serviceBrand: undefined;
+    /**
+    * Emitted when the focus of the window changes.
+    *
+    * Note: this considers the main window as well as auxiliary windows
+    * when they are in focus. As long as the main window or any of its
+    * auxiliary windows have focus, this event fires with `true`. It will
+    * fire with `false` when neither the main window nor any of its
+    * auxiliary windows have focus.
+    */
     readonly onDidChangeFocus: Event<boolean>;
+    /**
+    * Find out if the window or any of its auxiliary windows have focus.
+    */
     readonly hasFocus: boolean;
+    /**
+    * Find out if the window had the last focus.
+    */
     hadLastFocus(): Promise<boolean>;
+    /**
+    * Attempt to bring the window to the foreground and focus it.
+    *
+    * @param options How to focus the window, defaults to {@link FocusMode.Transfer}
+    */
     focus(targetWindow: Window, options?: {
         mode?: FocusMode;
     }): Promise<void>;
+    /**
+    * Emitted when the active window changes between main window
+    * and auxiliary windows.
+    */
     readonly onDidChangeActiveWindow: Event<number>;
+    /**
+    * Emitted when the window with the given identifier changes
+    * its fullscreen state.
+    */
     readonly onDidChangeFullScreen: Event<{
         windowId: number;
         fullscreen: boolean;
     }>;
+    /**
+    * Opens an empty window. The optional parameter allows to define if
+    * a new window should open or the existing one change to an empty.
+    */
     openWindow(options?: IOpenEmptyWindowOptions): Promise<void>;
+    /**
+    * Opens the provided array of openables in a window with the provided options.
+    */
     openWindow(toOpen: IWindowOpenable[], options?: IOpenWindowOptions): Promise<void>;
+    /**
+    * Switch between fullscreen and normal window.
+    */
     toggleFullScreen(targetWindow: Window): Promise<void>;
+    /**
+    * Bring a window to the front and restore it if needed.
+    */
     moveTop(targetWindow: Window): Promise<void>;
+    /**
+    * Get the location of the mouse cursor and its display bounds or `undefined` if unavailable.
+    */
     getCursorScreenPoint(): Promise<{
         readonly point: IPoint;
         readonly display: IRectangle;
     } | undefined>;
+    /**
+    * Restart the entire application.
+    */
     restart(): Promise<void>;
+    /**
+    * Reload the currently active main window.
+    */
     reload(options?: {
         disableExtensions?: boolean;
     }): Promise<void>;
+    /**
+    * Attempt to close the active main window.
+    */
     close(): Promise<void>;
+    /**
+    * Execute an asynchronous `expectedShutdownTask`. While this task is
+    * in progress, attempts to quit the application will not be vetoed with a dialog.
+    */
     withExpectedShutdown<T>(expectedShutdownTask: () => Promise<T>): Promise<T>;
+    /**
+    * Captures a screenshot.
+    */
     getScreenshot(rect?: IRectangle): Promise<VSBuffer | undefined>;
+    /**
+    * Get the native handle of the window.
+    */
     getNativeWindowHandle(windowId: number): Promise<VSBuffer | undefined>;
 }

package/vscode/src/vs/workbench/services/keybinding/common/fallbackKeyboardMapper.d.ts

@@ -2,6 +2,9 @@ import { ResolvedKeybinding, Keybinding } from "../../../../base/common/keybindi
 import { OperatingSystem } from "../../../../base/common/platform.js";
 import { IKeyboardEvent } from "../../../../platform/keybinding/common/keybinding.js";
 import { IKeyboardMapper } from "@codingame/monaco-vscode-keybindings-service-override/vscode/vs/platform/keyboardLayout/common/keyboardMapper";
+/**
+ * A keyboard mapper to be used when reading the keymap from the OS fails.
+ */
 export declare class FallbackKeyboardMapper implements IKeyboardMapper {
     private readonly _mapAltGrToCtrlAlt;
     private readonly _OS;

package/vscode/src/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.service.d.ts

@@ -2,6 +2,15 @@ import { URI } from "../../../../base/common/uri.js";
 export declare const ILanguageDetectionService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageDetectionService>;
 export interface ILanguageDetectionService {
     readonly _serviceBrand: undefined;
+    /**
+    * @param languageId The languageId to check if language detection is currently enabled.
+    * @returns whether or not language detection is on for this language.
+    */
     isEnabledForLanguage(languageId: string): boolean;
+    /**
+    * @param resource The resource to detect the language for.
+    * @param supportedLangs Optional. When populated, the model will only return languages from the provided list
+    * @returns the language id for the given resource or undefined if the model is not confident enough.
+    */
     detectLanguage(resource: URI, supportedLangs?: string[]): Promise<string | undefined>;
 }

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

@@ -9,53 +9,172 @@ import { PanelAlignment, Parts, SINGLE_WINDOW_PARTS, MULTI_WINDOW_PARTS, Positio
 export declare const IWorkbenchLayoutService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkbenchLayoutService>;
 export interface IWorkbenchLayoutService extends ILayoutService {
     readonly _serviceBrand: undefined;
+    /**
+    * Emits when the zen mode is enabled or disabled.
+    */
     readonly onDidChangeZenMode: Event<boolean>;
+    /**
+    * Emits when the target window is maximized or unmaximized.
+    */
     readonly onDidChangeWindowMaximized: Event<{
         readonly windowId: number;
         readonly maximized: boolean;
     }>;
+    /**
+    * Emits when main editor centered layout is enabled or disabled.
+    */
     readonly onDidChangeMainEditorCenteredLayout: Event<boolean>;
     readonly onDidChangePanelPosition: Event<string>;
+    /**
+    * Emit when panel alignment changes.
+    */
     readonly onDidChangePanelAlignment: Event<PanelAlignment>;
+    /**
+    * Emit when part visibility changes
+    */
     readonly onDidChangePartVisibility: Event<void>;
+    /**
+    * Emit when notifications (toasts or center) visibility changes.
+    */
     readonly onDidChangeNotificationsVisibility: Event<boolean>;
     readonly onDidChangeAuxiliaryBarMaximized: Event<void>;
+    /**
+    * True if a default layout with default editors was applied at startup
+    */
     readonly openedDefaultEditors: boolean;
+    /**
+    * Run a layout of the workbench.
+    */
     layout(): void;
+    /**
+    * Asks the part service if all parts have been fully restored. For editor part
+    * this means that the contents of visible editors have loaded.
+    */
     isRestored(): boolean;
+    /**
+    * A promise for to await the `isRestored()` condition to be `true`.
+    */
     readonly whenRestored: Promise<void>;
+    /**
+    * Returns whether the given part has the keyboard focus or not.
+    */
     hasFocus(part: Parts): boolean;
+    /**
+    * Focuses the part in the target window. If the part is not visible this is a noop.
+    */
     focusPart(part: SINGLE_WINDOW_PARTS): void;
     focusPart(part: MULTI_WINDOW_PARTS, targetWindow: Window): void;
     focusPart(part: Parts, targetWindow: Window): void;
+    /**
+    * Returns the target window container or parts HTML element within, if there is one.
+    */
     getContainer(targetWindow: Window): HTMLElement;
     getContainer(targetWindow: Window, part: Parts): HTMLElement | undefined;
+    /**
+    * Returns if the part is visible in the target window.
+    */
     isVisible(part: SINGLE_WINDOW_PARTS): boolean;
     isVisible(part: MULTI_WINDOW_PARTS, targetWindow: Window): boolean;
     isVisible(part: Parts, targetWindow: Window): boolean;
+    /**
+    * Set part hidden or not in the target window.
+    */
     setPartHidden(hidden: boolean, part: Parts): void;
+    /**
+    * Maximizes the panel height if the panel is not already maximized.
+    * Shrinks the panel to the default starting size if the panel is maximized.
+    */
     toggleMaximizedPanel(): void;
+    /**
+    * Returns true if the panel is maximized.
+    */
     isPanelMaximized(): boolean;
+    /**
+    * Maximizes the auxiliary sidebar by hiding the editor and panel areas.
+    * Restores the previous layout if the auxiliary sidebar is already maximized.
+    */
     toggleMaximizedAuxiliaryBar(): void;
+    /**
+    * Maximizes or restores the auxiliary sidebar.
+    *
+    * @returns `true` if there was a change in the maximization state.
+    */
     setAuxiliaryBarMaximized(maximized: boolean): boolean;
+    /**
+    * Returns true if the auxiliary sidebar is maximized.
+    */
     isAuxiliaryBarMaximized(): boolean;
+    /**
+    * Returns true if the main window has a border.
+    */
     hasMainWindowBorder(): boolean;
+    /**
+    * Returns the main window border radius if any.
+    */
     getMainWindowBorderRadius(): string | undefined;
+    /**
+    * Gets the current side bar position. Note that the sidebar can be hidden too.
+    */
     getSideBarPosition(): Position;
+    /**
+    * Toggles the menu bar visibility.
+    */
     toggleMenuBar(): void;
     getPanelPosition(): Position;
+    /**
+    * Sets the panel position.
+    */
     setPanelPosition(position: Position): void;
+    /**
+    * Gets the panel alignement.
+    */
     getPanelAlignment(): PanelAlignment;
+    /**
+    * Sets the panel alignment.
+    */
     setPanelAlignment(alignment: PanelAlignment): void;
+    /**
+    * Gets the maximum possible size for editor in the given container.
+    */
     getMaximumEditorDimensions(container: HTMLElement): IDimension;
+    /**
+    * Toggles the workbench in and out of zen mode - parts get hidden and window goes fullscreen.
+    */
     toggleZenMode(): void;
+    /**
+    * Returns whether the centered editor layout is active on the main editor part.
+    */
     isMainEditorLayoutCentered(): boolean;
+    /**
+    * Sets the main editor part in and out of centered layout.
+    */
     centerMainEditorLayout(active: boolean): void;
+    /**
+    * Get the provided parts size in the main window.
+    */
     getSize(part: Parts): IViewSize;
+    /**
+    * Set the provided parts size in the main window.
+    */
     setSize(part: Parts, size: IViewSize): void;
+    /**
+    * Resize the provided part in the main window.
+    */
     resizePart(part: Parts, sizeChangeWidth: number, sizeChangeHeight: number): void;
+    /**
+    * Register a part to participate in the layout.
+    */
     registerPart(part: Part): IDisposable;
+    /**
+    * Returns whether the target window is maximized.
+    */
     isWindowMaximized(targetWindow: Window): boolean;
+    /**
+    * Updates the maximized state of the target window.
+    */
     updateWindowMaximizedState(targetWindow: Window, maximized: boolean): void;
+    /**
+    * Returns the next visible view part in a given direction in the main window.
+    */
     getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined;
 }