@codingame/monaco-vscode-api 20.1.0 → 20.2.0

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

@@ -3,66 +3,258 @@ import { URI } from "../../../base/common/uri.js";
 import { IUriIdentityService } from "../../uriIdentity/common/uriIdentity.service.js";
 import { IRectangle } from "../../window/common/window.js";
 export interface IResolvableEditorModel extends IDisposable {
+    /**
+     * Resolves the model.
+     */
     resolve(): Promise<void>;
+    /**
+     * Find out if the editor model was resolved or not.
+     */
     isResolved(): boolean;
 }
 export declare function isResolvedEditorModel(model: IDisposable | undefined | null): model is IResolvableEditorModel;
 export interface IBaseUntypedEditorInput {
+    /**
+     * Optional options to use when opening the input.
+     */
     options?: IEditorOptions;
+    /**
+     * Label to show for the input.
+     */
     readonly label?: string;
+    /**
+     * Description to show for the input.
+     */
     readonly description?: string;
 }
 export interface IBaseResourceEditorInput extends IBaseUntypedEditorInput {
+    /**
+     * Hint to indicate that this input should be treated as a
+     * untitled file.
+     *
+     * Without this hint, the editor service will make a guess by
+     * looking at the scheme of the resource(s).
+     *
+     * Use `forceUntitled: true` when you pass in a `resource` that
+     * does not use the `untitled` scheme. The `resource` will then
+     * be used as associated path when saving the untitled file.
+     */
     readonly forceUntitled?: boolean;
 }
 export interface IBaseTextResourceEditorInput extends IBaseResourceEditorInput {
+    /**
+     * Optional options to use when opening the text input.
+     */
     options?: ITextEditorOptions;
+    /**
+     * The contents of the text input if known. If provided,
+     * the input will not attempt to load the contents from
+     * disk and may appear dirty.
+     */
     contents?: string;
+    /**
+     * The encoding of the text input if known.
+     */
     encoding?: string;
+    /**
+     * The identifier of the language id of the text input
+     * if known to use when displaying the contents.
+     */
     languageId?: string;
 }
 export interface IResourceEditorInput extends IBaseResourceEditorInput {
+    /**
+     * The resource URI of the resource to open.
+     */
     readonly resource: URI;
 }
 export interface ITextResourceEditorInput extends IResourceEditorInput, IBaseTextResourceEditorInput {
+    /**
+     * Optional options to use when opening the text input.
+     */
     options?: ITextEditorOptions;
 }
+/**
+ * This identifier allows to uniquely identify an editor with a
+ * resource, type and editor identifier.
+ */
 export interface IResourceEditorInputIdentifier {
+    /**
+     * The type of the editor.
+     */
     readonly typeId: string;
+    /**
+     * The identifier of the editor if provided.
+     */
     readonly editorId: string | undefined;
+    /**
+     * The resource URI of the editor.
+     */
     readonly resource: URI;
 }
 export declare enum EditorActivation {
+    /**
+     * Activate the editor after it opened. This will automatically restore
+     * the editor if it is minimized.
+     */
     ACTIVATE = 1,
+    /**
+     * Only restore the editor if it is minimized but do not activate it.
+     *
+     * Note: will only work in combination with the `preserveFocus: true` option.
+     * Otherwise, if focus moves into the editor, it will activate and restore
+     * automatically.
+     */
     RESTORE = 2,
+    /**
+     * Preserve the current active editor.
+     *
+     * Note: will only work in combination with the `preserveFocus: true` option.
+     * Otherwise, if focus moves into the editor, it will activate and restore
+     * automatically.
+     */
     PRESERVE = 3
 }
 export declare enum EditorResolution {
+    /**
+     * Displays a picker and allows the user to decide which editor to use.
+     */
     PICK = 0,
+    /**
+     * Only exclusive editors are considered.
+     */
     EXCLUSIVE_ONLY = 1
 }
 export declare enum EditorOpenSource {
+    /**
+     * Default: the editor is opening via a programmatic call
+     * to the editor service API.
+     */
     API = 0,
+    /**
+     * Indicates that a user action triggered the opening, e.g.
+     * via mouse or keyboard use.
+     */
     USER = 1
 }
 export interface IEditorOptions {
+    /**
+     * Tells the editor to not receive keyboard focus when the editor is being opened.
+     *
+     * Will also not activate the group the editor opens in unless the group is already
+     * the active one. This behaviour can be overridden via the `activation` option.
+     */
     preserveFocus?: boolean;
+    /**
+     * This option is only relevant if an editor is opened into a group that is not active
+     * already and allows to control if the inactive group should become active, restored
+     * or preserved.
+     *
+     * By default, the editor group will become active unless `preserveFocus` or `inactive`
+     * is specified.
+     */
     activation?: EditorActivation;
+    /**
+     * Tells the editor to reload the editor input in the editor even if it is identical to the one
+     * already showing. By default, the editor will not reload the input if it is identical to the
+     * one showing.
+     */
     forceReload?: boolean;
+    /**
+     * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
+     *
+     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
+     * to the side of another one or into a specific editor group.
+     */
     revealIfVisible?: boolean;
+    /**
+     * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
+     *
+     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
+     * to the side of another one or into a specific editor group.
+     */
     revealIfOpened?: boolean;
+    /**
+     * An editor that is pinned remains in the editor stack even when another editor is being opened.
+     * An editor that is not pinned will always get replaced by another editor that is not pinned.
+     */
     pinned?: boolean;
+    /**
+     * An editor that is sticky moves to the beginning of the editors list within the group and will remain
+     * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
+     */
     sticky?: boolean;
+    /**
+     * The index in the document stack where to insert the editor into when opening.
+     */
     index?: number;
+    /**
+     * An active editor that is opened will show its contents directly. Set to true to open an editor
+     * in the background without loading its contents.
+     *
+     * Will also not activate the group the editor opens in unless the group is already
+     * the active one. This behaviour can be overridden via the `activation` option.
+     */
     inactive?: boolean;
+    /**
+     * In case of an error opening the editor, will not present this error to the user (e.g. by showing
+     * a generic placeholder in the editor area). So it is up to the caller to provide error information
+     * in that case.
+     *
+     * By default, an error when opening an editor will result in a placeholder editor that shows the error.
+     * In certain cases a modal dialog may be presented to ask the user for further action.
+     */
     ignoreError?: boolean;
+    /**
+     * Allows to override the editor that should be used to display the input:
+     * - `undefined`: let the editor decide for itself
+     * - `string`: specific override by id
+     * - `EditorResolution`: specific override handling
+     */
     override?: string | EditorResolution;
+    /**
+     * A optional hint to signal in which context the editor opens.
+     *
+     * If configured to be `EditorOpenSource.USER`, this hint can be
+     * used in various places to control the experience. For example,
+     * if the editor to open fails with an error, a notification could
+     * inform about this in a modal dialog. If the editor opened through
+     * some background task, the notification would show in the background,
+     * not as a modal dialog.
+     */
     source?: EditorOpenSource;
+    /**
+     * An optional property to signal that certain view state should be
+     * applied when opening the editor.
+     */
     viewState?: object;
+    /**
+     * A transient editor will attempt to appear as preview and certain components
+     * (such as history tracking) may decide to ignore the editor when it becomes
+     * active.
+     * This option is meant to be used only when the editor is used for a short
+     * period of time, for example when opening a preview of the editor from a
+     * picker control in the background while navigating through results of the picker.
+     *
+     * Note: an editor that is already opened in a group that is not transient, will
+     * not turn transient.
+     */
     transient?: boolean;
+    /**
+     * Options that only apply when `AUX_WINDOW_GROUP` is used for opening.
+     */
     auxiliary?: {
+        /**
+         * Define the bounds of the editor window.
+         */
         bounds?: Partial<IRectangle>;
+        /**
+         * Show editor compact, hiding unnecessary elements.
+         */
         compact?: boolean;
+        /**
+         * Show the editor always on top of other windows.
+         */
         alwaysOnTop?: boolean;
     };
 }
@@ -73,19 +265,58 @@ export interface ITextEditorSelection {
     readonly endColumn?: number;
 }
 export declare enum TextEditorSelectionRevealType {
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range centered vertically.
+     */
     Center = 0,
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range centered vertically only if it lies outside the viewport.
+     */
     CenterIfOutsideViewport = 1,
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport, but not quite at the top.
+     */
     NearTop = 2,
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport, but not quite at the top.
+     * Only if it lies outside the viewport
+     */
     NearTopIfOutsideViewport = 3
 }
 export declare enum TextEditorSelectionSource {
+    /**
+     * Programmatic source indicates a selection change that
+     * was not triggered by the user via keyboard or mouse
+     * but through text editor APIs.
+     */
     PROGRAMMATIC = "api",
+    /**
+     * Navigation source indicates a selection change that
+     * was caused via some command or UI component such as
+     * an outline tree.
+     */
     NAVIGATION = "code.navigation",
+    /**
+     * Jump source indicates a selection change that
+     * was caused from within the text editor to another
+     * location in the same or different text editor such
+     * as "Go to definition".
+     */
     JUMP = "code.jump"
 }
 export interface ITextEditorOptions extends IEditorOptions {
+    /**
+     * Text editor selection.
+     */
     selection?: ITextEditorSelection;
+    /**
+     * Option to control the text editor selection reveal type.
+     * Defaults to TextEditorSelectionRevealType.Center
+     */
     selectionRevealType?: TextEditorSelectionRevealType;
+    /**
+     * Source of the call that caused the selection.
+     */
     selectionSource?: TextEditorSelectionSource | string;
 }
 export type ITextEditorChange = [

package/vscode/src/vs/platform/environment/common/argv.d.ts

@@ -3,6 +3,9 @@ export interface INativeCliOptions {
     "disable-telemetry"?: boolean;
     "telemetry-level"?: string;
 }
+/**
+ * A list of command line arguments we support natively.
+ */
 export interface NativeParsedArgs {
     tunnel?: INativeCliOptions & {
         user: {

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

@@ -6,4 +6,9 @@ export interface IExtensionHostDebugParams extends IDebugParams {
     debugId?: string;
     env?: Record<string, string>;
 }
+/**
+ * Type of extension.
+ *
+ * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
+ */
 export type ExtensionKind = "ui" | "workspace" | "web";

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

@@ -2,6 +2,11 @@ import { URI } from "../../../base/common/uri.js";
 import { NativeParsedArgs } from "./argv.js";
 import { IExtensionHostDebugParams, ExtensionKind } from "./environment.js";
 export declare const IEnvironmentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IEnvironmentService>;
+/**
+* A basic environment service that can be used in various processes,
+* such as main, renderer and shared process. Use subclasses of this
+* service for specific environment.
+*/
 export interface IEnvironmentService {
     readonly _serviceBrand: undefined;
     stateResource: URI;
@@ -37,8 +42,19 @@ export interface IEnvironmentService {
     policyFile?: URI;
 }
 export declare const INativeEnvironmentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<INativeEnvironmentService>;
+/**
+* A subclass of the `IEnvironmentService` to be used only in native
+* environments (Windows, Linux, macOS) but not e.g. web.
+*/
 export interface INativeEnvironmentService extends IEnvironmentService {
     args: NativeParsedArgs;
+    /**
+    * Root path of the JavaScript sources.
+    *
+    * Note: This is NOT the installation root
+    * directory itself but contained in it at
+    * a level that is platform dependent.
+    */
     appRoot: string;
     userHome: URI;
     appSettingsHome: URI;

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

@@ -323,30 +323,30 @@ export declare enum ExtensionManagementErrorCode {
 export declare enum ExtensionSignatureVerificationCode {
     "NotSigned" = "NotSigned",
     "Success" = "Success",
-    "RequiredArgumentMissing" = "RequiredArgumentMissing",
-    "InvalidArgument" = "InvalidArgument",
-    "PackageIsUnreadable" = "PackageIsUnreadable",
-    "UnhandledException" = "UnhandledException",
-    "SignatureManifestIsMissing" = "SignatureManifestIsMissing",
-    "SignatureManifestIsUnreadable" = "SignatureManifestIsUnreadable",
-    "SignatureIsMissing" = "SignatureIsMissing",
-    "SignatureIsUnreadable" = "SignatureIsUnreadable",
-    "CertificateIsUnreadable" = "CertificateIsUnreadable",
+    "RequiredArgumentMissing" = "RequiredArgumentMissing",// A required argument is missing.
+    "InvalidArgument" = "InvalidArgument",// An argument is invalid.
+    "PackageIsUnreadable" = "PackageIsUnreadable",// The extension package is unreadable.
+    "UnhandledException" = "UnhandledException",// An unhandled exception occurred.
+    "SignatureManifestIsMissing" = "SignatureManifestIsMissing",// The extension is missing a signature manifest file (.signature.manifest).
+    "SignatureManifestIsUnreadable" = "SignatureManifestIsUnreadable",// The signature manifest is unreadable.
+    "SignatureIsMissing" = "SignatureIsMissing",// The extension is missing a signature file (.signature.p7s).
+    "SignatureIsUnreadable" = "SignatureIsUnreadable",// The signature is unreadable.
+    "CertificateIsUnreadable" = "CertificateIsUnreadable",// The certificate is unreadable.
     "SignatureArchiveIsUnreadable" = "SignatureArchiveIsUnreadable",
-    "FileAlreadyExists" = "FileAlreadyExists",
+    "FileAlreadyExists" = "FileAlreadyExists",// The output file already exists.
     "SignatureArchiveIsInvalidZip" = "SignatureArchiveIsInvalidZip",
-    "SignatureArchiveHasSameSignatureFile" = "SignatureArchiveHasSameSignatureFile",
-    "PackageIntegrityCheckFailed" = "PackageIntegrityCheckFailed",
-    "SignatureIsInvalid" = "SignatureIsInvalid",
-    "SignatureManifestIsInvalid" = "SignatureManifestIsInvalid",
-    "SignatureIntegrityCheckFailed" = "SignatureIntegrityCheckFailed",
-    "EntryIsMissing" = "EntryIsMissing",
-    "EntryIsTampered" = "EntryIsTampered",
-    "Untrusted" = "Untrusted",
-    "CertificateRevoked" = "CertificateRevoked",
-    "SignatureIsNotValid" = "SignatureIsNotValid",
-    "UnknownError" = "UnknownError",
-    "PackageIsInvalidZip" = "PackageIsInvalidZip",
+    "SignatureArchiveHasSameSignatureFile" = "SignatureArchiveHasSameSignatureFile",// The signature archive has the same signature file.
+    "PackageIntegrityCheckFailed" = "PackageIntegrityCheckFailed",// The package integrity check failed.
+    "SignatureIsInvalid" = "SignatureIsInvalid",// The extension has an invalid signature file (.signature.p7s).
+    "SignatureManifestIsInvalid" = "SignatureManifestIsInvalid",// The extension has an invalid signature manifest file (.signature.manifest).
+    "SignatureIntegrityCheckFailed" = "SignatureIntegrityCheckFailed",// The extension's signature integrity check failed.  Extension integrity is suspect.
+    "EntryIsMissing" = "EntryIsMissing",// An entry referenced in the signature manifest was not found in the extension.
+    "EntryIsTampered" = "EntryIsTampered",// The integrity check for an entry referenced in the signature manifest failed.
+    "Untrusted" = "Untrusted",// An X.509 certificate in the extension signature is untrusted.
+    "CertificateRevoked" = "CertificateRevoked",// An X.509 certificate in the extension signature has been revoked.
+    "SignatureIsNotValid" = "SignatureIsNotValid",// The extension signature is invalid.
+    "UnknownError" = "UnknownError",// An unknown error occurred.
+    "PackageIsInvalidZip" = "PackageIsInvalidZip",// The extension package is not valid ZIP format.
     "SignatureArchiveHasTooManyEntries" = "SignatureArchiveHasTooManyEntries"
 }
 export declare class ExtensionManagementError extends Error {
@@ -375,6 +375,9 @@ export type InstallOptions = {
     productVersion?: IProductVersion;
     keepExisting?: boolean;
     downloadExtensionsLocally?: boolean;
+    /**
+     * Context passed through to InstallExtensionResult
+     */
     context?: IStringDictionary<any>;
 };
 export type UninstallOptions = {

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

@@ -6,6 +6,10 @@ import { URI } from "../../../base/common/uri.js";
 import { TargetPlatform, IExtensionManifest, type ExtensionType, type IExtension } from "../../extensions/common/extensions.js";
 import { IQueryOptions, IGalleryExtension, IExtensionInfo, IExtensionQueryOptions, IProductVersion, IExtensionIdentifier, IGalleryExtensionVersion, InstallOperation, StatisticType, ITranslation, IExtensionsControlManifest, type DidUninstallExtensionEvent, type DidUpdateExtensionMetadata, type IExtensionManagementParticipant, type ILocalExtension, type InstallExtensionEvent, type InstallExtensionInfo, type InstallExtensionResult, type InstallOptions, type Metadata, type UninstallExtensionEvent, type UninstallExtensionInfo, type UninstallOptions, type IConfigBasedExtensionTip, type IExecutableBasedExtensionTip, type AllowedExtensionsConfigValueType } from "./extensionManagement.js";
 export declare const IExtensionGalleryService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IExtensionGalleryService>;
+/**
+* Service to interact with the Visual Studio Code Marketplace to get extensions.
+* @throws Error if the Marketplace is not enabled or not reachable.
+*/
 export interface IExtensionGalleryService {
     readonly _serviceBrand: undefined;
     isEnabled(): boolean;

package/vscode/src/vs/platform/extensionManagement/common/extensionsProfileScannerService.d.ts

@@ -8,7 +8,13 @@ import { IUserDataProfilesService } from "../../userDataProfile/common/userDataP
 import { IUriIdentityService } from "../../uriIdentity/common/uriIdentity.service.js";
 import { IExtensionsProfileScannerService } from "./extensionsProfileScannerService.service.js";
 export declare enum ExtensionsProfileScanningErrorCode {
+    /**
+     * Error when trying to scan extensions from a profile that does not exist.
+     */
     ERROR_PROFILE_NOT_FOUND = "ERROR_PROFILE_NOT_FOUND",
+    /**
+     * Error when profile file is invalid.
+     */
     ERROR_INVALID_CONTENT = "ERROR_INVALID_CONTENT"
 }
 export declare class ExtensionsProfileScanningError extends Error {

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.d.ts

@@ -139,7 +139,14 @@ export declare class ExtensionManifestTranslator extends Disposable {
     constructor(fileService: IFileService, logService: ILogService);
     private getLocalizedMessages;
     translateManifest(extensionLocation: URI, extensionManifest: IExtensionManifest, nlsConfiguration: NlsConfiguration): Promise<IExtensionManifest>;
+    /**
+     * Parses original message bundle, returns null if the original message bundle is null.
+     */
     private resolveOriginalMessageBundle;
+    /**
+     * Finds localized message bundle and the original (unlocalized) one.
+     * If the localized file is not present, returns null for the original and marks original as localized.
+     */
     private findMessageBundles;
     protected formatMessage(extensionLocation: URI, message: string): string;
 }

package/vscode/src/vs/platform/extensionManagement/common/implicitActivationEvents.d.ts

@@ -8,7 +8,15 @@ export declare class ImplicitActivationEventsImpl {
     private readonly _generators;
     private readonly _cache;
     register<T>(extensionPointName: string, generator: IActivationEventsGenerator<T>): void;
+    /**
+     * This can run correctly only on the renderer process because that is the only place
+     * where all extension points and all implicit activation events generators are known.
+     */
     readActivationEvents(extensionDescription: IExtensionDescription): string[];
+    /**
+     * This can run correctly only on the renderer process because that is the only place
+     * where all extension points and all implicit activation events generators are known.
+     */
     createActivationEventsMap(extensionDescriptions: IExtensionDescription[]): {
         [extensionId: string]: string[];
     };

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

@@ -1,11 +1,26 @@
 import { URI } from "../../../base/common/uri.js";
 import { TargetPlatform } from "../../extensions/common/extensions.js";
 export declare const IExtensionResourceLoaderService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IExtensionResourceLoaderService>;
+/**
+* A service useful for reading resources from within extensions.
+*/
 export interface IExtensionResourceLoaderService {
     readonly _serviceBrand: undefined;
+    /**
+    * Read a certain resource within an extension.
+    */
     readExtensionResource(uri: URI): Promise<string>;
+    /**
+    * Returns whether the gallery provides extension resources.
+    */
     supportsExtensionGalleryResources(): Promise<boolean>;
+    /**
+    * Return true if the given URI is a extension gallery resource.
+    */
     isExtensionGalleryResource(uri: URI): Promise<boolean>;
+    /**
+    * Computes the URL of a extension gallery resource. Returns `undefined` if gallery does not provide extension resources.
+    */
     getExtensionGalleryResourceURL(galleryExtension: {
         publisher: string;
         name: string;