@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/platform/configuration/common/configurationRegistry.d.ts

@@ -16,53 +16,179 @@ export interface IConfigurationDelta {
     addedConfigurations?: IConfigurationNode[];
 }
 export interface IConfigurationRegistry {
+    /**
+     * Register a configuration to the registry.
+     */
     registerConfiguration(configuration: IConfigurationNode): IConfigurationNode;
+    /**
+     * Register multiple configurations to the registry.
+     */
     registerConfigurations(configurations: IConfigurationNode[], validate?: boolean): void;
+    /**
+     * Deregister multiple configurations from the registry.
+     */
     deregisterConfigurations(configurations: IConfigurationNode[]): void;
+    /**
+     * update the configuration registry by
+     * 	- registering the configurations to add
+     * 	- dereigstering the configurations to remove
+     */
     updateConfigurations(configurations: {
         add: IConfigurationNode[];
         remove: IConfigurationNode[];
     }): void;
+    /**
+     * Register multiple default configurations to the registry.
+     */
     registerDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void;
+    /**
+     * Deregister multiple default configurations from the registry.
+     */
     deregisterDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void;
+    /**
+     * Bulk update of the configuration registry (default and configurations, remove and add)
+     * @param delta
+     */
     deltaConfiguration(delta: IConfigurationDelta): void;
+    /**
+     * Return the registered default configurations
+     */
     getRegisteredDefaultConfigurations(): IConfigurationDefaults[];
+    /**
+     * Return the registered configuration defaults overrides
+     */
     getConfigurationDefaultsOverrides(): Map<string, IConfigurationDefaultOverrideValue>;
+    /**
+     * Signal that the schema of a configuration setting has changes. It is currently only supported to change enumeration values.
+     * Property or default value changes are not allowed.
+     */
     notifyConfigurationSchemaUpdated(...configurations: IConfigurationNode[]): void;
+    /**
+     * Event that fires whenever a configuration has been
+     * registered.
+     */
     readonly onDidSchemaChange: Event<void>;
+    /**
+     * Event that fires whenever a configuration has been
+     * registered.
+     */
     readonly onDidUpdateConfiguration: Event<{
         properties: ReadonlySet<string>;
         defaultsOverrides?: boolean;
     }>;
+    /**
+     * Returns all configuration nodes contributed to this registry.
+     */
     getConfigurations(): IConfigurationNode[];
+    /**
+     * Returns all configurations settings of all configuration nodes contributed to this registry.
+     */
     getConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;
+    /**
+     * Return all configurations by policy name
+     */
     getPolicyConfigurations(): Map<PolicyName, string>;
+    /**
+     * Returns all excluded configurations settings of all configuration nodes contributed to this registry.
+     */
     getExcludedConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;
+    /**
+     * Register the identifiers for editor configurations
+     */
     registerOverrideIdentifiers(identifiers: string[]): void;
 }
 export declare enum ConfigurationScope {
+    /**
+     * Application specific configuration, which can be configured only in default profile user settings.
+     */
     APPLICATION = 1,
+    /**
+     * Machine specific configuration, which can be configured only in local and remote user settings.
+     */
     MACHINE = 2,
+    /**
+     * An application machine specific configuration, which can be configured only in default profile user settings and remote user settings.
+     */
     APPLICATION_MACHINE = 3,
+    /**
+     * Window specific configuration, which can be configured in the user or workspace settings.
+     */
     WINDOW = 4,
+    /**
+     * Resource specific configuration, which can be configured in the user, workspace or folder settings.
+     */
     RESOURCE = 5,
+    /**
+     * Resource specific configuration that can be configured in language specific settings
+     */
     LANGUAGE_OVERRIDABLE = 6,
+    /**
+     * Machine specific configuration that can also be configured in workspace or folder settings.
+     */
     MACHINE_OVERRIDABLE = 7
 }
 export interface IConfigurationPropertySchema extends IJSONSchema {
     scope?: ConfigurationScope;
+    /**
+     * When restricted, value of this configuration will be read only from trusted sources.
+     * For eg., If the workspace is not trusted, then the value of this configuration is not read from workspace settings file.
+     */
     restricted?: boolean;
+    /**
+     * When `false` this property is excluded from the registry. Default is to include.
+     */
     included?: boolean;
+    /**
+     * List of tags associated to the property.
+     *  - A tag can be used for filtering
+     *  - Use `experimental` tag for marking the setting as experimental.
+     */
     tags?: string[];
+    /**
+     * When enabled this setting is ignored during sync and user can override this.
+     */
     ignoreSync?: boolean;
+    /**
+     * When enabled this setting is ignored during sync and user cannot override this.
+     */
     disallowSyncIgnore?: boolean;
+    /**
+     * Disallow extensions to contribute configuration default value for this setting.
+     */
     disallowConfigurationDefault?: boolean;
+    /**
+     * Labels for enumeration items
+     */
     enumItemLabels?: string[];
+    /**
+     * When specified, controls the presentation format of string settings.
+     * Otherwise, the presentation format defaults to `singleline`.
+     */
     editPresentation?: EditPresentationTypes;
+    /**
+     * When specified, gives an order number for the setting
+     * within the settings editor. Otherwise, the setting is placed at the end.
+     */
     order?: number;
+    /**
+     * When specified, this setting's value can always be overwritten by
+     * a system-wide policy.
+     */
     policy?: IPolicy;
+    /**
+     * When specified, this setting's default value can always be overwritten by
+     * an experiment.
+     */
     experiment?: {
+        /**
+         * The mode of the experiment.
+         * - `startup`: The setting value is updated to the experiment value only on startup.
+         * - `auto`: The setting value is updated to the experiment value automatically (whenever the experiment value changes).
+         */
         mode: "startup" | "auto";
+        /**
+         * The name of the experiment. By default, this is `config.${settingId}`
+         */
         name?: string;
     };
 }

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

@@ -1,6 +1,7 @@
 import { LexingError } from "./scanner.js";
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import { IContextKeyService } from "./contextkey.service.js";
+/** allow register constant context keys that are known only after startup; requires running `substituteConstants` on the context key - https://github.com/microsoft/vscode/issues/174218#issuecomment-1437972127 */
 export declare function setConstant(key: string, value: boolean): void;
 export declare enum ContextKeyExprType {
     False = 0,
@@ -45,6 +46,9 @@ export interface IContextKeyExpression {
 }
 export type ContextKeyExpression = (ContextKeyFalseExpr | ContextKeyTrueExpr | ContextKeyDefinedExpr | ContextKeyNotExpr | ContextKeyEqualsExpr | ContextKeyNotEqualsExpr | ContextKeyRegexExpr | ContextKeyNotRegexExpr | ContextKeyAndExpr | ContextKeyOrExpr | ContextKeyInExpr | ContextKeyNotInExpr | ContextKeyGreaterExpr | ContextKeyGreaterEqualsExpr | ContextKeySmallerExpr | ContextKeySmallerEqualsExpr);
 export type ParserConfig = {
+    /**
+     * with this option enabled, the parser can recover from regex parsing errors, e.g., unescaped slashes: `/src//` is accepted as `/src\//` would be
+     */
     regexParsingWithErrorRecovery: boolean;
 };
 export type ParsingError = {
@@ -53,6 +57,23 @@ export type ParsingError = {
     lexeme: string;
     additionalInfo?: string;
 };
+/**
+ * A parser for context key expressions.
+ *
+ * Example:
+ * ```ts
+ * const parser = new Parser();
+ * const expr = parser.parse('foo == "bar" && baz == true');
+ *
+ * if (expr === undefined) {
+ * 	// there were lexing or parsing errors
+ * 	// process lexing errors with `parser.lexingErrors`
+ *  // process parsing errors with `parser.parsingErrors`
+ * } else {
+ * 	// expr is a valid expression
+ * }
+ * ```
+ */
 export declare class Parser {
     private readonly _config;
     private static _parseError;
@@ -63,6 +84,12 @@ export declare class Parser {
     get lexingErrors(): Readonly<LexingError[]>;
     get parsingErrors(): Readonly<ParsingError[]>;
     constructor(_config?: ParserConfig);
+    /**
+     * Parse a context key expression.
+     *
+     * @param input the expression to parse
+     * @returns the parsed expression or `undefined` if there's an error - call `lexingErrors` and `parsingErrors` to see the errors
+     */
     parse(input: string): ContextKeyExpression | undefined;
     private _expr;
     private _or;
@@ -392,4 +419,7 @@ export interface IContextKeyChangeEvent {
     allKeysContainedIn(keys: IReadableSet<string>): boolean;
 }
 export type IScopedContextKeyService = IContextKeyService & IDisposable;
+/**
+ * Returns true if it is provable `p` implies `q`.
+ */
 export declare function implies(p: ContextKeyExpression, q: ContextKeyExpression): boolean;

package/vscode/src/vs/platform/contextkey/common/scanner.d.ts

@@ -91,11 +91,31 @@ export type Token = {
     type: TokenType.EOF;
     offset: number;
 };
+/**
+ * Example:
+ * `foo == bar'` - note how single quote doesn't have a corresponding closing quote,
+ * so it's reported as unexpected
+ */
 export type LexingError = {
-    offset: number;
+    offset: number; /** note that this doesn't take into account escape characters from the original encoding of the string, e.g., within an extension manifest file's JSON encoding  */
     lexeme: string;
     additionalInfo?: string;
 };
+/**
+ * A simple scanner for context keys.
+ *
+ * Example:
+ *
+ * ```ts
+ * const scanner = new Scanner().reset('resourceFileName =~ /docker/ && !config.docker.enabled');
+ * const tokens = [...scanner];
+ * if (scanner.errorTokens.length > 0) {
+ *     scanner.errorTokens.forEach(err => console.error(`Unexpected token at ${err.offset}: ${err.lexeme}\nHint: ${err.additional}`));
+ * } else {
+ *     // process tokens
+ * }
+ * ```
+ */
 export declare class Scanner {
     static getLexeme(token: Token): string;
     private static _regexFlags;

package/vscode/src/vs/platform/contextview/browser/contextView.d.ts

@@ -7,6 +7,12 @@ import { IMenuActionOptions, MenuId } from "../../actions/common/actions.js";
 import { IContextKeyService } from "../../contextkey/common/contextkey.service.js";
 export interface IContextViewDelegate {
     canRelayout?: boolean;
+    /**
+     * The anchor where to position the context view.
+     * Use a `HTMLElement` to position the view at the element,
+     * a `StandardMouseEvent` to position it at the mouse position
+     * or an `IAnchor` to position it at a specific location.
+     */
     getAnchor(): HTMLElement | StandardMouseEvent | IAnchor;
     render(container: HTMLElement): IDisposable;
     onDOMEvent?(e: any, activeElement: HTMLElement): void;
@@ -20,8 +26,20 @@ export interface IOpenContextView {
     close: () => void;
 }
 export type IContextMenuMenuDelegate = {
+    /**
+     * The MenuId that should be used to populate the context menu.
+     */
     menuId?: MenuId;
+    /**
+     * Optional options how menu actions are invoked
+     */
     menuActionOptions?: IMenuActionOptions;
+    /**
+     * Optional context key service which drives the given menu
+     */
     contextKeyService?: IContextKeyService;
+    /**
+     * Optional getter for extra actions. They will be prepended to the menu actions.
+     */
     getActions?(): IAction[];
 } & Omit<IContextMenuDelegate, "getActions">;

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

@@ -2,33 +2,120 @@ import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
 import { IConfirmation, IConfirmationResult, IPromptWithCustomCancel, IPromptResultWithCancel, IPromptWithDefaultCancel, IPromptResult, IPrompt, IInput, IInputResult, type ConfirmResult, type IOpenDialogOptions, type IPickAndOpenOptions, type ISaveDialogOptions } from "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/platform/dialogs/common/dialogs";
 export declare const IDialogService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IDialogService>;
+/**
+* A service to bring up modal dialogs.
+*
+* Note: use the `INotificationService.prompt()` method for a non-modal way to ask
+* the user for input.
+*/
 export interface IDialogService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event that fires when a dialog is about to show.
+    */
     onWillShowDialog: Event<void>;
+    /**
+    * An event that fires when a dialog did show (closed).
+    */
     onDidShowDialog: Event<void>;
+    /**
+    * Ask the user for confirmation with a modal dialog.
+    */
     confirm(confirmation: IConfirmation): Promise<IConfirmationResult>;
+    /**
+    * Prompt the user with a modal dialog. Provides a bit
+    * more control over the dialog compared to the simpler
+    * `confirm` method. Specifically, allows to show more
+    * than 2 buttons and makes it easier to just show a
+    * message to the user.
+    *
+    * @returns a promise that resolves to the `T` result
+    * from the provided `IPromptButton<T>` or `undefined`.
+    */
     prompt<T>(prompt: IPromptWithCustomCancel<T>): Promise<IPromptResultWithCancel<T>>;
     prompt<T>(prompt: IPromptWithDefaultCancel<T>): Promise<IPromptResult<T>>;
     prompt<T>(prompt: IPrompt<T>): Promise<IPromptResult<T>>;
+    /**
+    * Present a modal dialog to the user asking for input.
+    */
     input(input: IInput): Promise<IInputResult>;
+    /**
+    * Show a modal info dialog.
+    */
     info(message: string, detail?: string): Promise<void>;
+    /**
+    * Show a modal warning dialog.
+    */
     warn(message: string, detail?: string): Promise<void>;
+    /**
+    * Show a modal error dialog.
+    */
     error(message: string, detail?: string): Promise<void>;
+    /**
+    * Present the about dialog to the user.
+    */
     about(): Promise<void>;
 }
 export declare const IFileDialogService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IFileDialogService>;
+/**
+* A service to bring up file dialogs.
+*/
 export interface IFileDialogService {
     readonly _serviceBrand: undefined;
+    /**
+    * The default path for a new file based on previously used files.
+    * @param schemeFilter The scheme of the file path. If no filter given, the scheme of the current window is used.
+    * Falls back to user home in the absence of enough information to find a better URI.
+    */
     defaultFilePath(schemeFilter?: string): Promise<URI>;
+    /**
+    * The default path for a new folder based on previously used folders.
+    * @param schemeFilter The scheme of the folder path. If no filter given, the scheme of the current window is used.
+    * Falls back to user home in the absence of enough information to find a better URI.
+    */
     defaultFolderPath(schemeFilter?: string): Promise<URI>;
+    /**
+    * The default path for a new workspace based on previously used workspaces.
+    * @param schemeFilter The scheme of the workspace path. If no filter given, the scheme of the current window is used.
+    * Falls back to user home in the absence of enough information to find a better URI.
+    */
     defaultWorkspacePath(schemeFilter?: string): Promise<URI>;
+    /**
+    * Shows a file-folder selection dialog and opens the selected entry.
+    */
     pickFileFolderAndOpen(options: IPickAndOpenOptions): Promise<void>;
+    /**
+    * Shows a file selection dialog and opens the selected entry.
+    */
     pickFileAndOpen(options: IPickAndOpenOptions): Promise<void>;
+    /**
+    * Shows a folder selection dialog and opens the selected entry.
+    */
     pickFolderAndOpen(options: IPickAndOpenOptions): Promise<void>;
+    /**
+    * Shows a workspace selection dialog and opens the selected entry.
+    */
     pickWorkspaceAndOpen(options: IPickAndOpenOptions): Promise<void>;
+    /**
+    * Shows a save file dialog and save the file at the chosen file URI.
+    */
     pickFileToSave(defaultUri: URI, availableFileSystems?: string[]): Promise<URI | undefined>;
+    /**
+    * The preferred folder path to open the dialog at.
+    * @param schemeFilter The scheme of the file path. If no filter given, the scheme of the current window is used.
+    * Falls back to user home in the absence of a setting.
+    */
     preferredHome(schemeFilter?: string): Promise<URI>;
+    /**
+    * Shows a save file dialog and returns the chosen file URI.
+    */
     showSaveDialog(options: ISaveDialogOptions): Promise<URI | undefined>;
+    /**
+    * Shows a confirm dialog for saving 1-N files.
+    */
     showSaveConfirm(fileNamesOrResources: (string | URI)[]): Promise<ConfirmResult>;
+    /**
+    * Shows a open file dialog and returns the chosen file URI.
+    */
     showOpenDialog(options: IOpenDialogOptions): Promise<URI[] | undefined>;
 }

package/vscode/src/vs/platform/dnd/browser/dnd.d.ts

@@ -14,7 +14,16 @@ export declare const CodeDataTransfers: {
 };
 export interface IDraggedResourceEditorInput extends IBaseTextResourceEditorInput {
     resource: URI | undefined;
+    /**
+     * A hint that the source of the dragged editor input
+     * might not be the application but some external tool.
+     */
     isExternal?: boolean;
+    /**
+     * Whether we probe for the dropped editor to be a workspace
+     * (i.e. code-workspace file or even a folder), allowing to
+     * open it as workspace instead of opening as editor.
+     */
     allowWorkspaceOpen?: boolean;
 }
 export declare function extractEditorsDropData(e: DragEvent): Array<IDraggedResourceEditorInput>;
@@ -33,7 +42,13 @@ export interface IResourceStat {
     readonly selection?: ITextEditorSelection;
 }
 export interface IDragAndDropContributionRegistry {
+    /**
+     * Registers a drag and drop contribution.
+     */
     register(contribution: IDragAndDropContribution): void;
+    /**
+     * Returns all registered drag and drop contributions.
+     */
     getAll(): IterableIterator<IDragAndDropContribution>;
 }
 interface IDragAndDropContribution {
@@ -44,6 +59,9 @@ interface IDragAndDropContribution {
 export declare const Extensions: {
     DragAndDropContribution: string;
 };
+/**
+ * A singleton to store transfer data during drag & drop operations that are only valid within the application.
+ */
 export declare class LocalSelectionTransfer<T> {
     private static readonly INSTANCE;
     private data?;
@@ -77,5 +95,9 @@ export type MarkerTransferData = IMarker | {
 export declare function extractMarkerDropData(e: DragEvent): MarkerTransferData[] | undefined;
 export declare function fillInMarkersDragData(markerData: MarkerTransferData[], e: DragEvent): void;
 export declare function extractNotebookCellOutputDropData(e: DragEvent): NotebookCellOutputTransferData | undefined;
+/**
+ * A helper to get access to Electrons `webUtils.getPathForFile` function
+ * in a safe way without crashing the application when running in the web.
+ */
 export declare function getPathForFile(file: File): string | undefined;
 export {};