@codingame/monaco-vscode-api 1.81.5 → 1.81.7-next.0

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

@@ -44,6 +44,25 @@ interface IContextKeyExpression {
     negate(): ContextKeyExpression;
 }
 type ContextKeyExpression = (ContextKeyFalseExpr | ContextKeyTrueExpr | ContextKeyDefinedExpr | ContextKeyNotExpr | ContextKeyEqualsExpr | ContextKeyNotEqualsExpr | ContextKeyRegexExpr | ContextKeyNotRegexExpr | ContextKeyAndExpr | ContextKeyOrExpr | ContextKeyInExpr | ContextKeyNotInExpr | ContextKeyGreaterExpr | ContextKeyGreaterEqualsExpr | ContextKeySmallerExpr | ContextKeySmallerEqualsExpr);
+declare abstract class ContextKeyExpr {
+    static false(): ContextKeyExpression;
+    static true(): ContextKeyExpression;
+    static has(key: string): ContextKeyExpression;
+    static equals(key: string, value: any): ContextKeyExpression;
+    static notEquals(key: string, value: any): ContextKeyExpression;
+    static regex(key: string, value: RegExp): ContextKeyExpression;
+    static in(key: string, value: string): ContextKeyExpression;
+    static notIn(key: string, value: string): ContextKeyExpression;
+    static not(key: string): ContextKeyExpression;
+    static and(...expr: Array<ContextKeyExpression | undefined | null>): ContextKeyExpression | undefined;
+    static or(...expr: Array<ContextKeyExpression | undefined | null>): ContextKeyExpression | undefined;
+    static greater(key: string, value: number): ContextKeyExpression;
+    static greaterEquals(key: string, value: number): ContextKeyExpression;
+    static smaller(key: string, value: number): ContextKeyExpression;
+    static smallerEquals(key: string, value: number): ContextKeyExpression;
+    private static _parser;
+    static deserialize(serialized: string | null | undefined): ContextKeyExpression | undefined;
+}
 declare class ContextKeyFalseExpr implements IContextKeyExpression {
     static INSTANCE: ContextKeyFalseExpr;
     readonly type = ContextKeyExprType.False;
@@ -290,6 +309,25 @@ declare class ContextKeyOrExpr implements IContextKeyExpression {
     map(mapFnc: IContextKeyExprMapper): ContextKeyExpression;
     negate(): ContextKeyExpression;
 }
+interface ContextKeyInfo {
+    readonly key: string;
+    readonly type?: string;
+    readonly description?: string;
+}
+declare class RawContextKey<T extends ContextKeyValue> extends ContextKeyDefinedExpr {
+    private static _info;
+    static all(): IterableIterator<ContextKeyInfo>;
+    private readonly _defaultValue;
+    constructor(key: string, defaultValue: T | undefined, metaOrHide?: string | true | {
+        type: string;
+        description: string;
+    });
+    bindTo(target: IContextKeyService): IContextKey<T>;
+    getValue(target: IContextKeyService): T | undefined;
+    toNegated(): ContextKeyExpression;
+    isEqualTo(value: any): ContextKeyExpression;
+    notEqualsTo(value: any): ContextKeyExpression;
+}
 type ContextKeyValue = null | undefined | boolean | number | string | Array<null | undefined | boolean | number | string> | Record<string, null | undefined | boolean | number | string>;
 interface IContext {
     getValue<T extends ContextKeyValue = ContextKeyValue>(key: string): T | undefined;
@@ -328,4 +366,4 @@ interface IContextKeyService {
     updateParent(parentContextKeyService: IContextKeyService): void;
 }
 
-export { ContextKeyAndExpr, ContextKeyDefinedExpr, ContextKeyEqualsExpr, ContextKeyExprType, ContextKeyExpression, ContextKeyFalseExpr, ContextKeyGreaterEqualsExpr, ContextKeyGreaterExpr, ContextKeyInExpr, ContextKeyNotEqualsExpr, ContextKeyNotExpr, ContextKeyNotInExpr, ContextKeyNotRegexExpr, ContextKeyOrExpr, ContextKeyRegexExpr, ContextKeySmallerEqualsExpr, ContextKeySmallerExpr, ContextKeyTrueExpr, ContextKeyValue, IContext, IContextKey, IContextKeyChangeEvent, IContextKeyExprMapper, IContextKeyExpression, IContextKeyService, IContextKeyServiceTarget, IReadableSet, IScopedContextKeyService };
+export { ContextKeyAndExpr, ContextKeyDefinedExpr, ContextKeyEqualsExpr, ContextKeyExpr, ContextKeyExprType, ContextKeyExpression, ContextKeyFalseExpr, ContextKeyGreaterEqualsExpr, ContextKeyGreaterExpr, ContextKeyInExpr, ContextKeyInfo, ContextKeyNotEqualsExpr, ContextKeyNotExpr, ContextKeyNotInExpr, ContextKeyNotRegexExpr, ContextKeyOrExpr, ContextKeyRegexExpr, ContextKeySmallerEqualsExpr, ContextKeySmallerExpr, ContextKeyTrueExpr, ContextKeyValue, IContext, IContextKey, IContextKeyChangeEvent, IContextKeyExprMapper, IContextKeyExpression, IContextKeyService, IContextKeyServiceTarget, IReadableSet, IScopedContextKeyService, RawContextKey };

package/dist/vscode/vs/platform/keybinding/common/keybindingsRegistry.d.ts

@@ -1,3 +1,18 @@
+import { Keybinding } from '../../../base/common/keybindings.js';
+import { ICommandHandler, ICommandHandlerDescription } from '../../commands/common/commands.js';
+import { ContextKeyExpression } from '../../contextkey/common/contextkey.js';
+import { IDisposable } from '../../../base/common/lifecycle.js';
+
+interface IKeybindingItem {
+    keybinding: Keybinding | null;
+    command: string | null;
+    commandArgs?: any;
+    when: ContextKeyExpression | null | undefined;
+    weight1: number;
+    weight2: number;
+    extensionId: string | null;
+    isBuiltinExtension: boolean;
+}
 interface IKeybindings {
     primary?: number;
     secondary?: number[];
@@ -14,5 +29,31 @@ interface IKeybindings {
         secondary?: number[];
     };
 }
+interface IKeybindingRule extends IKeybindings {
+    id: string;
+    weight: number;
+    args?: any;
+    when?: ContextKeyExpression | null | undefined;
+}
+interface IExtensionKeybindingRule {
+    keybinding: Keybinding | null;
+    id: string;
+    args?: any;
+    weight: number;
+    when: ContextKeyExpression | undefined;
+    extensionId?: string;
+    isBuiltinExtension?: boolean;
+}
+interface ICommandAndKeybindingRule extends IKeybindingRule {
+    handler: ICommandHandler;
+    description?: ICommandHandlerDescription | null;
+}
+interface IKeybindingsRegistry {
+    registerKeybindingRule(rule: IKeybindingRule): IDisposable;
+    setExtensionKeybindings(rules: IExtensionKeybindingRule[]): void;
+    registerCommandAndKeybindingRule(desc: ICommandAndKeybindingRule): IDisposable;
+    getDefaultKeybindings(): IKeybindingItem[];
+}
+declare const KeybindingsRegistry: IKeybindingsRegistry;
 
-export { IKeybindings };
+export { ICommandAndKeybindingRule, IExtensionKeybindingRule, IKeybindingItem, IKeybindingRule, IKeybindings, IKeybindingsRegistry, KeybindingsRegistry };

package/dist/vscode/vs/platform/workspace/common/workspaceTrust.d.ts

@@ -1,3 +1,7 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { Event } from '../../../base/common/event.js';
+import { URI } from '../../../base/common/uri.js';
+
 interface WorkspaceTrustRequestButton {
     readonly label: string;
     readonly type: 'ContinueWithTrust' | 'ContinueWithoutTrust' | 'Manage' | 'Cancel';
@@ -6,5 +10,23 @@ interface WorkspaceTrustRequestOptions {
     readonly buttons?: WorkspaceTrustRequestButton[];
     readonly message?: string;
 }
+declare const enum WorkspaceTrustUriResponse {
+    Open = 1,
+    OpenInNewWindow = 2,
+    Cancel = 3
+}
+declare const IWorkspaceTrustRequestService: ServiceIdentifier<IWorkspaceTrustRequestService>;
+interface IWorkspaceTrustRequestService {
+    readonly _serviceBrand: undefined;
+    readonly onDidInitiateOpenFilesTrustRequest: Event<void>;
+    readonly onDidInitiateWorkspaceTrustRequest: Event<WorkspaceTrustRequestOptions | undefined>;
+    readonly onDidInitiateWorkspaceTrustRequestOnStartup: Event<void>;
+    completeOpenFilesTrustRequest(result: WorkspaceTrustUriResponse, saveResponse?: boolean): Promise<void>;
+    requestOpenFilesTrust(openFiles: URI[]): Promise<WorkspaceTrustUriResponse>;
+    cancelWorkspaceTrustRequest(): void;
+    completeWorkspaceTrustRequest(trusted?: boolean): Promise<void>;
+    requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    requestWorkspaceTrustOnStartup(): void;
+}
 
-export { WorkspaceTrustRequestButton, WorkspaceTrustRequestOptions };
+export { IWorkspaceTrustRequestService, WorkspaceTrustRequestButton, WorkspaceTrustRequestOptions, WorkspaceTrustUriResponse };

package/dist/vscode/vs/workbench/browser/parts/editor/editor.d.ts

@@ -0,0 +1,20 @@
+import { IEditorIdentifier } from '../../../common/editor.js';
+import { Event } from '../../../../base/common/event.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+
+/**
+ * A sub-interface of IEditorService to hide some workbench-core specific
+ * events from clients.
+ */
+interface EditorServiceImpl extends IEditorService {
+    /**
+     * Emitted when an editor failed to open.
+     */
+    readonly onDidOpenEditorFail: Event<IEditorIdentifier>;
+    /**
+     * Emitted when the list of most recently active editors change.
+     */
+    readonly onDidMostRecentlyActiveEditorsChange: Event<void>;
+}
+
+export { EditorServiceImpl };

package/dist/vscode/vs/workbench/services/editor/browser/editorService.d.ts

@@ -0,0 +1,105 @@
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IEditorOptions, IResourceEditorInput, ITextResourceEditorInput, IResourceEditorInputIdentifier } from '../../../../platform/editor/common/editor.js';
+import { IEditorCloseEvent, IEditorIdentifier, IVisibleEditorPane, EditorsOrder, IEditorPane, IUntypedEditorInput, IUntitledTextResourceEditorInput, IResourceDiffEditorInput, ITextDiffEditorPane, EditorInputWithOptions, IFindEditorOptions, GroupIdentifier, IRevertOptions } from '../../../common/editor.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { Event } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IEditorGroupsService, ICloseEditorOptions, IEditorGroup, IEditorReplacement } from '../common/editorGroupsService.js';
+import { IEditorsChangeEvent, PreferredGroup, IOpenEditorsOptions, IUntypedEditorReplacement, ISaveEditorsOptions, ISaveEditorsResult, ISaveAllEditorsOptions, IRevertAllEditorsOptions } from '../common/editorService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { ICodeEditor, IDiffEditor } from '../../../../editor/browser/editorBrowser.js';
+import { EditorServiceImpl } from '../../../browser/parts/editor/editor.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IEditorResolverService } from '../common/editorResolverService.js';
+import { IWorkspaceTrustRequestService } from '../../../../platform/workspace/common/workspaceTrust.js';
+import { IHostService } from '../../host/browser/host.js';
+import { ITextEditorService } from '../../textfile/common/textEditorService.js';
+
+declare class EditorService extends Disposable implements EditorServiceImpl {
+    private readonly editorGroupService;
+    private readonly instantiationService;
+    private readonly fileService;
+    private readonly configurationService;
+    private readonly contextService;
+    private readonly uriIdentityService;
+    private readonly editorResolverService;
+    private readonly workspaceTrustRequestService;
+    private readonly hostService;
+    private readonly textEditorService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidActiveEditorChange;
+    readonly onDidActiveEditorChange: Event<void>;
+    private readonly _onDidVisibleEditorsChange;
+    readonly onDidVisibleEditorsChange: Event<void>;
+    private readonly _onDidEditorsChange;
+    readonly onDidEditorsChange: Event<IEditorsChangeEvent>;
+    private readonly _onDidCloseEditor;
+    readonly onDidCloseEditor: Event<IEditorCloseEvent>;
+    private readonly _onDidOpenEditorFail;
+    readonly onDidOpenEditorFail: Event<IEditorIdentifier>;
+    private readonly _onDidMostRecentlyActiveEditorsChange;
+    readonly onDidMostRecentlyActiveEditorsChange: Event<void>;
+    constructor(editorGroupService: IEditorGroupsService, instantiationService: IInstantiationService, fileService: IFileService, configurationService: IConfigurationService, contextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService, editorResolverService: IEditorResolverService, workspaceTrustRequestService: IWorkspaceTrustRequestService, hostService: IHostService, textEditorService: ITextEditorService);
+    private registerListeners;
+    private lastActiveEditor;
+    private onEditorGroupsReady;
+    private handleActiveEditorChange;
+    private doHandleActiveEditorChangeEvent;
+    private registerGroupListeners;
+    private readonly activeOutOfWorkspaceWatchers;
+    private handleVisibleEditorsChange;
+    private onDidRunFileOperation;
+    private onDidFilesChange;
+    private handleMovedFile;
+    private closeOnFileDelete;
+    private onConfigurationUpdated;
+    private handleDeletedFile;
+    private getAllNonDirtyEditors;
+    private readonly editorsObserver;
+    get activeEditorPane(): IVisibleEditorPane | undefined;
+    get activeTextEditorControl(): ICodeEditor | IDiffEditor | undefined;
+    get activeTextEditorLanguageId(): string | undefined;
+    get count(): number;
+    get editors(): EditorInput[];
+    getEditors(order: EditorsOrder, options?: {
+        excludeSticky?: boolean;
+    }): readonly IEditorIdentifier[];
+    get activeEditor(): EditorInput | undefined;
+    get visibleEditorPanes(): IVisibleEditorPane[];
+    get visibleTextEditorControls(): Array<ICodeEditor | IDiffEditor>;
+    get visibleEditors(): EditorInput[];
+    openEditor(editor: EditorInput, options?: IEditorOptions, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: IUntypedEditorInput, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: IResourceEditorInput, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: ITextResourceEditorInput | IUntitledTextResourceEditorInput, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: IResourceDiffEditorInput, group?: PreferredGroup): Promise<ITextDiffEditorPane | undefined>;
+    openEditor(editor: EditorInput | IUntypedEditorInput, optionsOrPreferredGroup?: IEditorOptions | PreferredGroup, preferredGroup?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditors(editors: EditorInputWithOptions[], group?: PreferredGroup, options?: IOpenEditorsOptions): Promise<IEditorPane[]>;
+    openEditors(editors: IUntypedEditorInput[], group?: PreferredGroup, options?: IOpenEditorsOptions): Promise<IEditorPane[]>;
+    openEditors(editors: Array<EditorInputWithOptions | IUntypedEditorInput>, group?: PreferredGroup, options?: IOpenEditorsOptions): Promise<IEditorPane[]>;
+    private handleWorkspaceTrust;
+    private extractEditorResources;
+    isOpened(editor: IResourceEditorInputIdentifier): boolean;
+    isVisible(editor: EditorInput): boolean;
+    closeEditor({ editor, groupId }: IEditorIdentifier, options?: ICloseEditorOptions): Promise<void>;
+    closeEditors(editors: IEditorIdentifier[], options?: ICloseEditorOptions): Promise<void>;
+    findEditors(resource: URI, options?: IFindEditorOptions): readonly IEditorIdentifier[];
+    findEditors(editor: IResourceEditorInputIdentifier, options?: IFindEditorOptions): readonly IEditorIdentifier[];
+    findEditors(resource: URI, options: IFindEditorOptions | undefined, group: IEditorGroup | GroupIdentifier): readonly EditorInput[];
+    findEditors(editor: IResourceEditorInputIdentifier, options: IFindEditorOptions | undefined, group: IEditorGroup | GroupIdentifier): EditorInput | undefined;
+    findEditors(arg1: URI | IResourceEditorInputIdentifier, options: IFindEditorOptions | undefined, arg2?: IEditorGroup | GroupIdentifier): readonly IEditorIdentifier[] | readonly EditorInput[] | EditorInput | undefined;
+    replaceEditors(replacements: IUntypedEditorReplacement[], group: IEditorGroup | GroupIdentifier): Promise<void>;
+    replaceEditors(replacements: IEditorReplacement[], group: IEditorGroup | GroupIdentifier): Promise<void>;
+    save(editors: IEditorIdentifier | IEditorIdentifier[], options?: ISaveEditorsOptions): Promise<ISaveEditorsResult>;
+    saveAll(options?: ISaveAllEditorsOptions): Promise<ISaveEditorsResult>;
+    revert(editors: IEditorIdentifier | IEditorIdentifier[], options?: IRevertOptions): Promise<boolean>;
+    revertAll(options?: IRevertAllEditorsOptions): Promise<boolean>;
+    private getAllModifiedEditors;
+    private getUniqueEditors;
+    dispose(): void;
+}
+
+export { EditorService };