@codingame/monaco-vscode-api 20.1.1 → 20.2.1

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

@@ -6,22 +6,71 @@ import { IRectangle } from "../../../../platform/window/common/window.js";
 import { GroupIdentifier } from "../../../common/editor.js";
 import { IEditorGroupsContainer, IAuxiliaryEditorPart, IEditorPart, IEditorGroup, IEditorWorkingSet, IEditorWorkingSetOptions, IEditorGroupContextKeyProvider } from "./editorGroupsService.js";
 export declare const IEditorGroupsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEditorGroupsService>;
+/**
+* The main service to interact with editor groups across all opened editor parts.
+*/
 export interface IEditorGroupsService extends IEditorGroupsContainer {
     readonly _serviceBrand: undefined;
+    /**
+    * An event for when a new auxiliary editor part is created.
+    */
     readonly onDidCreateAuxiliaryEditorPart: Event<IAuxiliaryEditorPart>;
+    /**
+    * Provides access to the main window editor part.
+    */
     readonly mainPart: IEditorPart;
+    /**
+    * Provides access to all editor parts.
+    */
     readonly parts: ReadonlyArray<IEditorPart>;
+    /**
+    * Get the editor part that contains the group with the provided identifier.
+    */
     getPart(group: IEditorGroup | GroupIdentifier): IEditorPart;
+    /**
+    * Get the editor part that is rooted in the provided container.
+    */
     getPart(container: unknown): IEditorPart;
+    /**
+    * Opens a new window with a full editor part instantiated
+    * in there at the optional position and size on screen.
+    */
     createAuxiliaryEditorPart(options?: {
         bounds?: Partial<IRectangle>;
         compact?: boolean;
         alwaysOnTop?: boolean;
     }): Promise<IAuxiliaryEditorPart>;
+    /**
+    * Returns the instantiation service that is scoped to the
+    * provided editor part. Use this method when building UI
+    * that contributes to auxiliary editor parts to ensure the
+    * UI is scoped to that part.
+    */
     getScopedInstantiationService(part: IEditorPart): IInstantiationService;
+    /**
+    * Save a new editor working set from the currently opened
+    * editors and group layout.
+    */
     saveWorkingSet(name: string): IEditorWorkingSet;
+    /**
+    * Returns all known editor working sets.
+    */
     getWorkingSets(): IEditorWorkingSet[];
+    /**
+    * Applies the working set. Use `empty` to apply an empty working set.
+    *
+    * @returns `true` when the working set as applied.
+    */
     applyWorkingSet(workingSet: IEditorWorkingSet | "empty", options?: IEditorWorkingSetOptions): Promise<boolean>;
+    /**
+    * Deletes a working set.
+    */
     deleteWorkingSet(workingSet: IEditorWorkingSet): void;
+    /**
+    * Registers a context key provider. This provider sets a context key for each scoped editor group context and the global context.
+    *
+    * @param provider - The context key provider to be registered.
+    * @returns - A disposable object to unregister the provider.
+    */
     registerContextKeyProvider<T extends ContextKeyValue>(provider: IEditorGroupContextKeyProvider<T>): IDisposable;
 }

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

@@ -3,6 +3,12 @@ import { IWillInstantiateEditorPaneEvent } from "../../../common/editor.js";
 export declare const IEditorPaneService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEditorPaneService>;
 export interface IEditorPaneService {
     readonly _serviceBrand: undefined;
+    /**
+    * Emitted when an editor pane is about to be instantiated.
+    */
     readonly onWillInstantiateEditorPane: Event<IWillInstantiateEditorPaneEvent>;
+    /**
+    * Returns whether a editor pane with the given type id has been instantiated.
+    */
     didInstantiateEditorPane(typeId: string): boolean;
 }

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.d.ts

@@ -21,13 +21,25 @@ export declare enum RegisteredEditorPriority {
     exclusive = "exclusive",
     default = "default"
 }
+/**
+ * If we didn't resolve an editor dictates what to do with the opening state
+ * ABORT = Do not continue with opening the editor
+ * NONE = Continue as if the resolution has been disabled as the service could not resolve one
+ */
 export declare enum ResolvedStatus {
     ABORT = 1,
     NONE = 2
 }
 export type ResolvedEditor = EditorInputWithOptionsAndGroup | ResolvedStatus;
 export type RegisteredEditorOptions = {
+    /**
+     * If your editor cannot be opened in multiple groups for the same resource
+     */
     singlePerResource?: boolean | (() => boolean);
+    /**
+     * Whether or not you can support opening the given resource.
+     * If omitted we assume you can open everything
+     */
     canSupportResource?: (resource: URI) => boolean;
 };
 export type RegisteredEditorInfo = {

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

@@ -8,13 +8,54 @@ import { PreferredGroup } from "./editorService.js";
 export declare const IEditorResolverService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEditorResolverService>;
 export interface IEditorResolverService {
     readonly _serviceBrand: undefined;
+    /**
+    * Given a resource finds the editor associations that match it from the user's settings
+    * @param resource The resource to match
+    * @return The matching associations
+    */
     getAssociationsForResource(resource: URI): EditorAssociations;
+    /**
+    * Updates the user's association to include a specific editor ID as a default for the given glob pattern
+    * @param globPattern The glob pattern (must be a string as settings don't support relative glob)
+    * @param editorID The ID of the editor to make a user default
+    */
     updateUserAssociations(globPattern: string, editorID: string): void;
+    /**
+    * Emitted when an editor is registered or unregistered.
+    */
     readonly onDidChangeEditorRegistrations: Event<void>;
+    /**
+    * Given a callback, run the callback pausing the registration emitter
+    */
     bufferChangeEvents(callback: Function): void;
+    /**
+    * Registers a specific editor. Editors with the same glob pattern and ID will be grouped together by the resolver.
+    * This allows for registration of the factories in different locations
+    * @param globPattern The glob pattern for this registration
+    * @param editorInfo Information about the registration
+    * @param options Specific options which apply to this registration
+    * @param editorFactoryObject The editor input factory functions
+    */
     registerEditor(globPattern: string | glob.IRelativePattern, editorInfo: RegisteredEditorInfo, options: RegisteredEditorOptions, editorFactoryObject: EditorInputFactoryObject): IDisposable;
+    /**
+    * Given an editor resolves it to the suitable ResolvedEitor based on user extensions, settings, and built-in editors
+    * @param editor The editor to resolve
+    * @param preferredGroup The group you want to open the editor in
+    * @returns An EditorInputWithOptionsAndGroup if there is an available editor or a status of how to proceed
+    */
     resolveEditor(editor: IUntypedEditorInput, preferredGroup: PreferredGroup | undefined): Promise<ResolvedEditor>;
+    /**
+    * Given a resource returns all the editor ids that match that resource. If there is exclusive editor we return an empty array
+    * @param resource The resource
+    * @returns A list of editor ids
+    */
     getEditors(resource: URI): RegisteredEditorInfo[];
+    /**
+    * A set of all the editors that are registered to the editor resolver.
+    */
     getEditors(): RegisteredEditorInfo[];
+    /**
+    * Get a complete list of editor associations.
+    */
     getAllUserAssociations(): EditorAssociations;
 }

package/vscode/src/vs/workbench/services/editor/common/editorService.d.ts

@@ -2,30 +2,68 @@ import { GroupIdentifier, ISaveOptions, IRevertOptions, IUntypedEditorInput } fr
 import { EditorInput } from "../../../common/editor/editorInput.js";
 import { IEditorGroup } from "./editorGroupsService.js";
 import { IGroupModelChangeEvent } from "@codingame/monaco-vscode-622c0cca-d5fa-59b6-b730-0715afcf93ee-common/vscode/vs/workbench/common/editor/editorGroupModel";
+/**
+ * Open an editor in the currently active group.
+ */
 export declare const ACTIVE_GROUP = -1;
 export type ACTIVE_GROUP_TYPE = typeof ACTIVE_GROUP;
+/**
+ * Open an editor to the side of the active group.
+ */
 export declare const SIDE_GROUP = -2;
 export type SIDE_GROUP_TYPE = typeof SIDE_GROUP;
+/**
+ * Open an editor in a new auxiliary window.
+ */
 export declare const AUX_WINDOW_GROUP = -3;
 export type AUX_WINDOW_GROUP_TYPE = typeof AUX_WINDOW_GROUP;
 export type PreferredGroup = IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE;
 export declare function isPreferredGroup(obj: unknown): obj is PreferredGroup;
 export interface ISaveEditorsOptions extends ISaveOptions {
+    /**
+     * If true, will ask for a location of the editor to save to.
+     */
     readonly saveAs?: boolean;
 }
 export interface ISaveEditorsResult {
+    /**
+     * Whether the save operation was successful.
+     */
     readonly success: boolean;
+    /**
+     * Resulting editors after the save operation.
+     */
     readonly editors: Array<EditorInput | IUntypedEditorInput>;
 }
 export interface IUntypedEditorReplacement {
+    /**
+     * The editor to replace.
+     */
     readonly editor: EditorInput;
+    /**
+     * The replacement for the editor.
+     */
     readonly replacement: IUntypedEditorInput;
+    /**
+     * Skips asking the user for confirmation and doesn't
+     * save the document. Only use this if you really need to!
+    */
     forceReplaceDirty?: boolean;
 }
 export interface IBaseSaveRevertAllEditorOptions {
+    /**
+     * Whether to include untitled editors as well.
+     */
     readonly includeUntitled?: {
+        /**
+         * Whether to include scratchpad editors.
+         * Scratchpads are not included if not specified.
+         */
         readonly includeScratchpad: boolean;
     } | boolean;
+    /**
+     * Whether to exclude sticky editors.
+     */
     readonly excludeSticky?: boolean;
 }
 export interface ISaveAllEditorsOptions extends ISaveEditorsOptions, IBaseSaveRevertAllEditorOptions {
@@ -33,9 +71,16 @@ export interface ISaveAllEditorsOptions extends ISaveEditorsOptions, IBaseSaveRe
 export interface IRevertAllEditorsOptions extends IRevertOptions, IBaseSaveRevertAllEditorOptions {
 }
 export interface IOpenEditorsOptions {
+    /**
+     * Whether to validate trust when opening editors
+     * that are potentially not inside the workspace.
+     */
     readonly validateTrust?: boolean;
 }
 export interface IEditorsChangeEvent {
+    /**
+     * The group which had the editor change
+     */
     groupId: GroupIdentifier;
     event: IGroupModelChangeEvent;
 }

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

@@ -10,40 +10,214 @@ import { IEditorsChangeEvent, SIDE_GROUP_TYPE, ACTIVE_GROUP_TYPE, AUX_WINDOW_GRO
 export declare const IEditorService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEditorService>;
 export interface IEditorService {
     readonly _serviceBrand: undefined;
+    /**
+    * Emitted when the currently active editor changes.
+    *
+    * @see {@link IEditorService.activeEditorPane}
+    */
     readonly onDidActiveEditorChange: Event<void>;
+    /**
+    * Emitted when any of the current visible editors changes.
+    *
+    * @see {@link IEditorService.visibleEditorPanes}
+    */
     readonly onDidVisibleEditorsChange: Event<void>;
+    /**
+    * An aggregated event for any change to any editor across
+    * all groups.
+    */
     readonly onDidEditorsChange: Event<IEditorsChangeEvent>;
+    /**
+    * Emitted when an editor is about to open.
+    */
     readonly onWillOpenEditor: Event<IEditorWillOpenEvent>;
+    /**
+    * Emitted when an editor is closed.
+    */
     readonly onDidCloseEditor: Event<IEditorCloseEvent>;
+    /**
+    * The currently active editor pane or `undefined` if none. The editor pane is
+    * the workbench container for editors of any kind.
+    *
+    * @see {@link IEditorService.activeEditor} for access to the active editor input
+    */
     readonly activeEditorPane: IVisibleEditorPane | undefined;
+    /**
+    * The currently active editor or `undefined` if none. An editor is active when it is
+    * located in the currently active editor group. It will be `undefined` if the active
+    * editor group has no editors open.
+    */
     readonly activeEditor: EditorInput | undefined;
+    /**
+    * The currently active text editor control or `undefined` if there is currently no active
+    * editor or the active editor widget is neither a text nor a diff editor.
+    *
+    * @see {@link IEditorService.activeEditor}
+    */
     readonly activeTextEditorControl: IEditor | IDiffEditor | undefined;
+    /**
+    * The currently active text editor language id or `undefined` if there is currently no active
+    * editor or the active editor control is neither a text nor a diff editor. If the active
+    * editor is a diff editor, the modified side's language id will be taken.
+    */
     readonly activeTextEditorLanguageId: string | undefined;
+    /**
+    * All editor panes that are currently visible across all editor groups.
+    *
+    * @see {@link IEditorService.visibleEditors} for access to the visible editor inputs
+    */
     readonly visibleEditorPanes: readonly IVisibleEditorPane[];
+    /**
+    * All editors that are currently visible. An editor is visible when it is opened in an
+    * editor group and active in that group. Multiple editor groups can be opened at the same time.
+    */
     readonly visibleEditors: readonly EditorInput[];
+    /**
+    * All text editor widgets that are currently visible across all editor groups. A text editor
+    * widget is either a text or a diff editor.
+    *
+    * This property supports side-by-side editors as well, by returning both sides if they are
+    * text editor widgets.
+    */
     readonly visibleTextEditorControls: readonly (IEditor | IDiffEditor)[];
+    /**
+    * All text editor widgets that are currently visible across all editor groups. A text editor
+    * widget is either a text or a diff editor.
+    *
+    * This property supports side-by-side editors as well, by returning both sides if they are
+    * text editor widgets.
+    *
+    * @param order the order of the editors to use
+    */
     getVisibleTextEditorControls(order: EditorsOrder): readonly (IEditor | IDiffEditor)[];
+    /**
+    * All editors that are opened across all editor groups in sequential order
+    * of appearance.
+    *
+    * This includes active as well as inactive editors in each editor group.
+    */
     readonly editors: readonly EditorInput[];
+    /**
+    * The total number of editors that are opened either inactive or active.
+    */
     readonly count: number;
+    /**
+    * All editors that are opened across all editor groups with their group
+    * identifier.
+    *
+    * @param order the order of the editors to use
+    * @param options whether to exclude sticky editors or not
+    */
     getEditors(order: EditorsOrder, options?: {
         excludeSticky?: boolean;
     }): readonly IEditorIdentifier[];
+    /**
+    * Open an editor in an editor group.
+    *
+    * @param editor the editor to open
+    * @param options the options to use for the editor
+    * @param group the target group. If unspecified, the editor will open in the currently
+    * active group. Use `SIDE_GROUP` to open the editor in a new editor group to the side
+    * of the currently active group.
+    *
+    * @returns the editor that opened or `undefined` if the operation failed or the editor was not
+    * opened to be active.
+    */
     openEditor(editor: IResourceEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): Promise<IEditorPane | undefined>;
     openEditor(editor: ITextResourceEditorInput | IUntitledTextResourceEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): Promise<IEditorPane | undefined>;
     openEditor(editor: ITextResourceDiffEditorInput | IResourceDiffEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): Promise<ITextDiffEditorPane | undefined>;
     openEditor(editor: IUntypedEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): Promise<IEditorPane | undefined>;
+    /**
+    * @deprecated using this method is a sign that your editor has not adopted the editor
+    * resolver yet. Please use `IEditorResolverService.registerEditor` to make your editor
+    * known to the workbench and then use untyped editor inputs for opening:
+    *
+    * ```ts
+    * editorService.openEditor({ resource });
+    * ```
+    *
+    * If you already have an `EditorInput` in hand and must use it for opening, use `group.openEditor`
+    * instead, via `IEditorGroupsService`.
+    */
     openEditor(editor: EditorInput, options?: IEditorOptions, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): Promise<IEditorPane | undefined>;
+    /**
+    * Open editors in an editor group.
+    *
+    * @param editors the editors to open with associated options
+    * @param group the target group. If unspecified, the editor will open in the currently
+    * active group. Use `SIDE_GROUP` to open the editor in a new editor group to the side
+    * of the currently active group.
+    *
+    * @returns the editors that opened. The array can be empty or have less elements for editors
+    * that failed to open or were instructed to open as inactive.
+    */
     openEditors(editors: IUntypedEditorInput[], group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE, options?: IOpenEditorsOptions): Promise<readonly IEditorPane[]>;
+    /**
+    * Replaces editors in an editor group with the provided replacement.
+    *
+    * @param replacements the editors to replace
+    * @param group the editor group
+    *
+    * @returns a promise that is resolved when the replaced active
+    * editor (if any) has finished loading.
+    */
     replaceEditors(replacements: IUntypedEditorReplacement[], group: IEditorGroup | GroupIdentifier): Promise<void>;
+    /**
+    * Find out if the provided editor is opened in any editor group.
+    *
+    * Note: An editor can be opened but not actively visible.
+    *
+    * Note: This method will return `true` if a side by side editor
+    * is opened where the `primary` editor matches too.
+    */
     isOpened(editor: IResourceEditorInputIdentifier): boolean;
+    /**
+    * Find out if the provided editor is visible in any editor group.
+    */
     isVisible(editor: EditorInput): boolean;
+    /**
+    * Close an editor in a specific editor group.
+    */
     closeEditor(editor: IEditorIdentifier, options?: ICloseEditorOptions): Promise<void>;
+    /**
+    * Close multiple editors in specific editor groups.
+    */
     closeEditors(editors: readonly IEditorIdentifier[], options?: ICloseEditorOptions): Promise<void>;
+    /**
+    * This method will return an entry for each editor that reports
+    * a `resource` that matches the provided one in the group or
+    * across all groups.
+    *
+    * It is possible that multiple editors are returned in case the
+    * same resource is opened in different editors. To find the specific
+    * editor, use the `IResourceEditorInputIdentifier` as input.
+    */
     findEditors(resource: URI, options?: IFindEditorOptions): readonly IEditorIdentifier[];
     findEditors(editor: IResourceEditorInputIdentifier, options?: IFindEditorOptions): readonly IEditorIdentifier[];
+    /**
+    * Save the provided list of editors.
+    */
     save(editors: IEditorIdentifier | readonly IEditorIdentifier[], options?: ISaveEditorsOptions): Promise<ISaveEditorsResult>;
+    /**
+    * Save all editors.
+    */
     saveAll(options?: ISaveAllEditorsOptions): Promise<ISaveEditorsResult>;
+    /**
+    * Reverts the provided list of editors.
+    *
+    * @returns `true` if all editors reverted and `false` otherwise.
+    */
     revert(editors: IEditorIdentifier | readonly IEditorIdentifier[], options?: IRevertOptions): Promise<boolean>;
+    /**
+    * Reverts all editors.
+    *
+    * @returns `true` if all editors reverted and `false` otherwise.
+    */
     revertAll(options?: IRevertAllEditorsOptions): Promise<boolean>;
+    /**
+    * Create a scoped editor service that only operates on the provided
+    * editor group container. Use `main` to create a scoped editor service
+    * to the main editor group container of the main window.
+    */
     createScoped(editorGroupsContainer: IEditorGroupsContainer, disposables: DisposableStore): IEditorService;
 }

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

@@ -2,6 +2,10 @@ import { URI } from "../../../../base/common/uri.js";
 import { IEnvironmentService } from "../../../../platform/environment/common/environment.service.js";
 import { IPath } from "../../../../platform/window/common/window.js";
 export declare const IWorkbenchEnvironmentService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkbenchEnvironmentService>;
+/**
+* A workbench specific environment service that is only present in workbench
+* layer.
+*/
 export interface IWorkbenchEnvironmentService extends IEnvironmentService {
     readonly logFile: URI;
     readonly windowLogsPath: URI;

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

@@ -53,21 +53,65 @@ export interface IWorkbenchExtensionManagementService extends IProfileAwareExten
 export declare const IWorkbenchExtensionEnablementService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkbenchExtensionEnablementService>;
 export interface IWorkbenchExtensionEnablementService {
     readonly _serviceBrand: undefined;
+    /**
+    * Event to listen on for extension enablement changes
+    */
     readonly onEnablementChanged: Event<readonly IExtension[]>;
+    /**
+    * Returns the enablement state for the given extension
+    */
     getEnablementState(extension: IExtension): EnablementState;
+    /**
+    * Returns the enablement states for the given extensions
+    * @param extensions list of extensions
+    * @param workspaceTypeOverrides Workspace type overrides
+    */
     getEnablementStates(extensions: IExtension[], workspaceTypeOverrides?: {
         trusted?: boolean;
     }): EnablementState[];
+    /**
+    * Returns the enablement states for the dependencies of the given extension
+    */
     getDependenciesEnablementStates(extension: IExtension): [
         IExtension,
         EnablementState
     ][];
+    /**
+    * Returns `true` if the enablement can be changed.
+    */
     canChangeEnablement(extension: IExtension): boolean;
+    /**
+    * Returns `true` if the enablement can be changed.
+    */
     canChangeWorkspaceEnablement(extension: IExtension): boolean;
+    /**
+    * Returns `true` if the given extension is enabled.
+    */
     isEnabled(extension: IExtension): boolean;
+    /**
+    * Returns `true` if the given enablement state is enabled enablement state.
+    */
     isEnabledEnablementState(enablementState: EnablementState): boolean;
+    /**
+    * Returns `true` if the given extension identifier is disabled globally.
+    * Extensions can be disabled globally or in workspace or both.
+    * If an extension is disabled in both then enablement state shows only workspace.
+    * This will
+    */
     isDisabledGlobally(extension: IExtension): boolean;
+    /**
+    * Enable or disable the given extension.
+    * if `workspace` is `true` then enablement is done for workspace, otherwise globally.
+    *
+    * Returns a promise that resolves to boolean value.
+    * if resolves to `true` then requires restart for the change to take effect.
+    *
+    * Throws error if enablement is requested for workspace and there is no workspace
+    */
     setEnablement(extensions: IExtension[], state: EnablementState): Promise<boolean[]>;
+    /**
+    * Updates the enablement state of the extensions when workspace trust changes.
+    */
     updateExtensionsEnablementsWhenWorkspaceTrustChanges(): Promise<void>;
 }
 export declare const IWebExtensionsScannerService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWebExtensionsScannerService>;

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

@@ -26,6 +26,9 @@ export interface IExtensionHostInitData {
     quality: string | undefined;
     commit?: string;
     date?: string;
+    /**
+     * When set to `0`, no polling for the parent process still running will happen.
+     */
     parentPid: number | 0;
     environment: IEnvironment;
     workspace?: IStaticWorkspaceData | null;

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

@@ -19,6 +19,9 @@ export interface IResolveAuthorityOKResult {
 export type IResolveAuthorityResult = IResolveAuthorityErrorResult | IResolveAuthorityOKResult;
 export interface IExtensionHostProxy {
     resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult>;
+    /**
+     * Returns `null` if no resolver for `remoteAuthority` is found.
+     */
     getCanonicalURI(remoteAuthority: string, uri: URI): Promise<URI | null>;
     startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
     extensionTestsExecute(): Promise<number>;

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

@@ -33,17 +33,55 @@ export declare class MissingExtensionDependency {
     readonly dependency: string;
     constructor(dependency: string);
 }
+/**
+ * e.g.
+ * ```
+ * {
+ *    startTime: 1511954813493000,
+ *    endTime: 1511954835590000,
+ *    deltas: [ 100, 1500, 123456, 1500, 100000 ],
+ *    ids: [ 'idle', 'self', 'extension1', 'self', 'idle' ]
+ * }
+ * ```
+ */
 export interface IExtensionHostProfile {
+    /**
+     * Profiling start timestamp in microseconds.
+     */
     startTime: number;
+    /**
+     * Profiling end timestamp in microseconds.
+     */
     endTime: number;
+    /**
+     * Duration of segment in microseconds.
+     */
     deltas: number[];
+    /**
+     * Segment identifier: extension id or one of the four known strings.
+     */
     ids: ProfileSegmentId[];
+    /**
+     * Get the information as a .cpuprofile.
+     */
     data: IV8Profile;
+    /**
+     * Get the aggregated time per segmentId
+     */
     getAggregatedTimes(): Map<ProfileSegmentId, number>;
 }
 export declare enum ExtensionHostStartup {
+    /**
+     * The extension host should be launched immediately and doesn't require a `$startExtensionHost` call.
+     */
     EagerAutoStart = 1,
+    /**
+     * The extension host should be launched immediately and needs a `$startExtensionHost` call.
+     */
     EagerManualStart = 2,
+    /**
+     * The extension host should be launched lazily and only when it has extensions it needs to host. It doesn't require a `$startExtensionHost` call.
+     */
     LazyAutoStart = 3
 }
 export interface IExtensionInspectInfo {
@@ -57,6 +95,11 @@ export interface IExtensionHost {
     readonly runningLocation: ExtensionRunningLocation;
     readonly remoteAuthority: string | null;
     readonly startup: ExtensionHostStartup;
+    /**
+     * A collection of extensions which includes information about which
+     * extension will execute or is executing on this extension host.
+     * **NOTE**: this will reflect extensions correctly only after `start()` resolves.
+     */
     readonly extensions: ExtensionHostExtensions | null;
     readonly onExit: Event<[
         number,
@@ -86,6 +129,9 @@ export declare class ExtensionHostExtensions {
 }
 export declare function isProposedApiEnabled(extension: IExtensionDescription, proposal: ApiProposalName): boolean;
 export declare function checkProposedApiEnabled(extension: IExtensionDescription, proposal: ApiProposalName): void;
+/**
+ * Extension id or one of the four known program states.
+ */
 export type ProfileSegmentId = string | "idle" | "program" | "gc" | "self";
 export interface ExtensionActivationReason {
     readonly startup: boolean;
@@ -111,6 +157,9 @@ export interface IWillActivateEvent {
 export interface IResponsiveStateChangeEvent {
     extensionHostKind: ExtensionHostKind;
     isResponsive: boolean;
+    /**
+     * Return the inspect port or `0`. `0` means inspection is not possible.
+     */
     getInspectListener(tryEnableInspector: boolean): Promise<IExtensionInspectInfo | undefined>;
 }
 export declare enum ActivationKind {
@@ -118,8 +167,23 @@ export declare enum ActivationKind {
     Immediate = 1
 }
 export interface WillStopExtensionHostsEvent {
+    /**
+     * A human readable reason for stopping the extension hosts
+     * that e.g. can be shown in a confirmation dialog to the
+     * user.
+     */
     readonly reason: string;
+    /**
+     * A flag to indicate if the operation was triggered automatically
+     */
     readonly auto: boolean;
+    /**
+     * Allows to veto the stopping of extension hosts. The veto can be a long running
+     * operation.
+     *
+     * @param reason a human readable reason for vetoing the extension host stop in case
+     * where the resolved `value: true`.
+     */
     veto(value: boolean | Promise<boolean>, reason: string): void;
 }
 export interface IInternalExtensionService {