@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/contrib/output/common/outputChannelModel.js

@@ -0,0 +1,317 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ThrottledDelayer, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { Disposable, MutableDisposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { ILogService, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { OutputChannelUpdateMode } from '../../../services/output/common/output.js';
+class OutputFileListener extends Disposable {
+    constructor(file, fileService, logService) {
+        super();
+        this.file = file;
+        this.fileService = fileService;
+        this.logService = logService;
+        this._onDidContentChange = ( new Emitter());
+        this.onDidContentChange = this._onDidContentChange.event;
+        this.watching = false;
+        this.syncDelayer = ( new ThrottledDelayer(500));
+    }
+    watch(eTag) {
+        if (!this.watching) {
+            this.etag = eTag;
+            this.poll();
+            this.logService.trace('Started polling', ( this.file.toString()));
+            this.watching = true;
+        }
+    }
+    poll() {
+        const loop = () => this.doWatch().then(() => this.poll());
+        this.syncDelayer.trigger(loop);
+    }
+    async doWatch() {
+        const stat = await this.fileService.stat(this.file);
+        if (stat.etag !== this.etag) {
+            this.etag = stat.etag;
+            this._onDidContentChange.fire(stat.size);
+        }
+    }
+    unwatch() {
+        if (this.watching) {
+            this.syncDelayer.cancel();
+            this.watching = false;
+            this.logService.trace('Stopped polling', ( this.file.toString()));
+        }
+    }
+    dispose() {
+        this.unwatch();
+        super.dispose();
+    }
+}
+let FileOutputChannelModel = class FileOutputChannelModel extends Disposable {
+    constructor(modelUri, language, file, fileService, modelService, logService, editorWorkerService) {
+        super();
+        this.modelUri = modelUri;
+        this.language = language;
+        this.file = file;
+        this.fileService = fileService;
+        this.modelService = modelService;
+        this.editorWorkerService = editorWorkerService;
+        this._onDispose = this._register(( new Emitter()));
+        this.onDispose = this._onDispose.event;
+        this.etag = '';
+        this.loadModelPromise = null;
+        this.model = null;
+        this.modelUpdateInProgress = false;
+        this.modelUpdateCancellationSource = this._register(( new MutableDisposable()));
+        this.appendThrottler = this._register(( new ThrottledDelayer(300)));
+        this.startOffset = 0;
+        this.endOffset = 0;
+        this.fileHandler = this._register(( new OutputFileListener(this.file, this.fileService, logService)));
+        this._register(this.fileHandler.onDidContentChange(size => this.onDidContentChange(size)));
+        this._register(toDisposable(() => this.fileHandler.unwatch()));
+    }
+    append(message) {
+        throw new Error('Not supported');
+    }
+    replace(message) {
+        throw new Error('Not supported');
+    }
+    clear() {
+        this.update(OutputChannelUpdateMode.Clear, this.endOffset, true);
+    }
+    update(mode, till, immediate) {
+        const loadModelPromise = this.loadModelPromise ? this.loadModelPromise : Promise.resolve();
+        loadModelPromise.then(() => this.doUpdate(mode, till, immediate));
+    }
+    loadModel() {
+        this.loadModelPromise = Promises.withAsyncBody(async (c, e) => {
+            try {
+                let content = '';
+                if (await this.fileService.exists(this.file)) {
+                    const fileContent = await this.fileService.readFile(this.file, { position: this.startOffset });
+                    this.endOffset = this.startOffset + fileContent.value.byteLength;
+                    this.etag = fileContent.etag;
+                    content = ( fileContent.value.toString());
+                }
+                else {
+                    this.startOffset = 0;
+                    this.endOffset = 0;
+                }
+                c(this.createModel(content));
+            }
+            catch (error) {
+                e(error);
+            }
+        });
+        return this.loadModelPromise;
+    }
+    createModel(content) {
+        if (this.model) {
+            this.model.setValue(content);
+        }
+        else {
+            this.model = this.modelService.createModel(content, this.language, this.modelUri);
+            this.fileHandler.watch(this.etag);
+            const disposable = this.model.onWillDispose(() => {
+                this.cancelModelUpdate();
+                this.fileHandler.unwatch();
+                this.model = null;
+                dispose(disposable);
+            });
+        }
+        return this.model;
+    }
+    doUpdate(mode, till, immediate) {
+        if (mode === OutputChannelUpdateMode.Clear || mode === OutputChannelUpdateMode.Replace) {
+            this.startOffset = this.endOffset = isNumber(till) ? till : this.endOffset;
+            this.cancelModelUpdate();
+        }
+        if (!this.model) {
+            return;
+        }
+        this.modelUpdateInProgress = true;
+        if (!this.modelUpdateCancellationSource.value) {
+            this.modelUpdateCancellationSource.value = ( new CancellationTokenSource());
+        }
+        const token = this.modelUpdateCancellationSource.value.token;
+        if (mode === OutputChannelUpdateMode.Clear) {
+            this.clearContent(this.model);
+        }
+        else if (mode === OutputChannelUpdateMode.Replace) {
+            this.replacePromise = this.replaceContent(this.model, token).finally(() => this.replacePromise = undefined);
+        }
+        else {
+            this.appendContent(this.model, immediate, token);
+        }
+    }
+    clearContent(model) {
+        this.doUpdateModel(model, [EditOperation.delete(model.getFullModelRange())], VSBuffer.fromString(''));
+    }
+    async appendContent(model, immediate, token) {
+        this.appendThrottler.trigger(async () => {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            if (this.replacePromise) {
+                try {
+                    await this.replacePromise;
+                }
+                catch (e) {  }
+                if (token.isCancellationRequested) {
+                    return;
+                }
+            }
+            const contentToAppend = await this.getContentToUpdate();
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const lastLine = model.getLineCount();
+            const lastLineMaxColumn = model.getLineMaxColumn(lastLine);
+            const edits = [EditOperation.insert(( new Position(lastLine, lastLineMaxColumn)), ( contentToAppend.toString()))];
+            this.doUpdateModel(model, edits, contentToAppend);
+        }, immediate ? 0 : undefined);
+    }
+    async replaceContent(model, token) {
+        const contentToReplace = await this.getContentToUpdate();
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const edits = await this.getReplaceEdits(model, ( contentToReplace.toString()));
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.doUpdateModel(model, edits, contentToReplace);
+    }
+    async getReplaceEdits(model, contentToReplace) {
+        if (!contentToReplace) {
+            return [EditOperation.delete(model.getFullModelRange())];
+        }
+        if (contentToReplace !== model.getValue()) {
+            const edits = await this.editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: ( contentToReplace.toString()), range: model.getFullModelRange() }]);
+            if (edits?.length) {
+                return ( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)));
+            }
+        }
+        return [];
+    }
+    doUpdateModel(model, edits, content) {
+        if (edits.length) {
+            model.applyEdits(edits);
+        }
+        this.endOffset = this.endOffset + content.byteLength;
+        this.modelUpdateInProgress = false;
+    }
+    cancelModelUpdate() {
+        this.modelUpdateCancellationSource.value?.cancel();
+        this.modelUpdateCancellationSource.value = undefined;
+        this.appendThrottler.cancel();
+        this.replacePromise = undefined;
+        this.modelUpdateInProgress = false;
+    }
+    async getContentToUpdate() {
+        const content = await this.fileService.readFile(this.file, { position: this.endOffset });
+        this.etag = content.etag;
+        return content.value;
+    }
+    onDidContentChange(size) {
+        if (this.model) {
+            if (!this.modelUpdateInProgress) {
+                if (isNumber(size) && this.endOffset > size) {
+                    this.update(OutputChannelUpdateMode.Clear, 0, true);
+                }
+            }
+            this.update(OutputChannelUpdateMode.Append, undefined, false );
+        }
+    }
+    isVisible() {
+        return !!this.model;
+    }
+    dispose() {
+        this._onDispose.fire();
+        super.dispose();
+    }
+};
+FileOutputChannelModel = ( __decorate([
+    ( __param(3, IFileService)),
+    ( __param(4, IModelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IEditorWorkerService))
+], FileOutputChannelModel));
+let OutputChannelBackedByFile = class OutputChannelBackedByFile extends FileOutputChannelModel {
+    constructor(id, modelUri, language, file, fileService, modelService, loggerService, logService, editorWorkerService) {
+        super(modelUri, language, file, fileService, modelService, logService, editorWorkerService);
+        this.logger = loggerService.createLogger(file, { logLevel: 'always', donotRotate: true, donotUseFormatters: true, hidden: true });
+        this._offset = 0;
+    }
+    append(message) {
+        this.write(message);
+        this.update(OutputChannelUpdateMode.Append, undefined, this.isVisible());
+    }
+    replace(message) {
+        const till = this._offset;
+        this.write(message);
+        this.update(OutputChannelUpdateMode.Replace, till, true);
+    }
+    write(content) {
+        this._offset += VSBuffer.fromString(content).byteLength;
+        this.logger.info(content);
+        if (this.isVisible()) {
+            this.logger.flush();
+        }
+    }
+};
+OutputChannelBackedByFile = ( __decorate([
+    ( __param(4, IFileService)),
+    ( __param(5, IModelService)),
+    ( __param(6, ILoggerService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IEditorWorkerService))
+], OutputChannelBackedByFile));
+let DelegatedOutputChannelModel = class DelegatedOutputChannelModel extends Disposable {
+    constructor(id, modelUri, language, outputDir, instantiationService, fileService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.fileService = fileService;
+        this._onDispose = this._register(( new Emitter()));
+        this.onDispose = this._onDispose.event;
+        this.outputChannelModel = this.createOutputChannelModel(id, modelUri, language, outputDir);
+    }
+    async createOutputChannelModel(id, modelUri, language, outputDirPromise) {
+        const outputDir = await outputDirPromise;
+        const file = resources.joinPath(outputDir, `${id.replace(/[\\/:\*\?"<>\|]/g, '')}.log`);
+        await this.fileService.createFile(file);
+        const outputChannelModel = this._register(this.instantiationService.createInstance(OutputChannelBackedByFile, id, modelUri, language, file));
+        this._register(outputChannelModel.onDispose(() => this._onDispose.fire()));
+        return outputChannelModel;
+    }
+    append(output) {
+        this.outputChannelModel.then(outputChannelModel => outputChannelModel.append(output));
+    }
+    update(mode, till, immediate) {
+        this.outputChannelModel.then(outputChannelModel => outputChannelModel.update(mode, till, immediate));
+    }
+    loadModel() {
+        return this.outputChannelModel.then(outputChannelModel => outputChannelModel.loadModel());
+    }
+    clear() {
+        this.outputChannelModel.then(outputChannelModel => outputChannelModel.clear());
+    }
+    replace(value) {
+        this.outputChannelModel.then(outputChannelModel => outputChannelModel.replace(value));
+    }
+};
+DelegatedOutputChannelModel = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IFileService))
+], DelegatedOutputChannelModel));
+export { DelegatedOutputChannelModel, FileOutputChannelModel };

package/dist/vscode/vs/workbench/contrib/output/common/outputChannelModelService.js

@@ -0,0 +1,31 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { toLocalISOString } from '../../../../base/common/date.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { FileOutputChannelModel, DelegatedOutputChannelModel } from './outputChannelModel.js';
+const IOutputChannelModelService = ( createDecorator('outputChannelModelService'));
+let OutputChannelModelService = class OutputChannelModelService {
+    constructor(fileService, instantiationService, environmentService) {
+        this.fileService = fileService;
+        this.instantiationService = instantiationService;
+        this._outputDir = null;
+        this.outputLocation = joinPath(environmentService.windowLogsPath, `output_${toLocalISOString(( new Date())).replace(/-|:|\.\d+Z$/g, '')}`);
+    }
+    createOutputChannelModel(id, modelUri, language, file) {
+        return file ? this.instantiationService.createInstance(FileOutputChannelModel, modelUri, language, file) : this.instantiationService.createInstance(DelegatedOutputChannelModel, id, modelUri, language, this.outputDir);
+    }
+    get outputDir() {
+        if (!this._outputDir) {
+            this._outputDir = this.fileService.createFolder(this.outputLocation).then(() => this.outputLocation);
+        }
+        return this._outputDir;
+    }
+};
+OutputChannelModelService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IWorkbenchEnvironmentService))
+], OutputChannelModelService));
+export { IOutputChannelModelService, OutputChannelModelService };

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js

@@ -0,0 +1,153 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { MenuId, MenuItemAction, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { AbstractEditorCommandsQuickAccessProvider } from 'monaco-editor/esm/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js';
+import { Language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { DefaultQuickAccessFilterValue } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
+    get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
+    get defaultFilterValue() {
+        if (this.configuration.preserveInput) {
+            return DefaultQuickAccessFilterValue.LAST;
+        }
+        return undefined;
+    }
+    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService) {
+        super({
+            showAlias: !Language.isDefaultVariant(),
+            noResultsPick: {
+                label: ( localize('noCommandResults', "No matching commands")),
+                commandId: ''
+            }
+        }, instantiationService, keybindingService, commandService, telemetryService, dialogService);
+        this.editorService = editorService;
+        this.menuService = menuService;
+        this.extensionService = extensionService;
+        this.configurationService = configurationService;
+        this.editorGroupService = editorGroupService;
+        this.preferencesService = preferencesService;
+        this.productService = productService;
+        this.extensionRegistrationRace = Promise.race([
+            timeout(800),
+            this.extensionService.whenInstalledExtensionsRegistered()
+        ]);
+        this._register(configurationService.onDidChangeConfiguration((e) => this.updateSuggestedCommandIds(e)));
+        this.updateSuggestedCommandIds();
+    }
+    get configuration() {
+        const commandPaletteConfig = this.configurationService.getValue().workbench.commandPalette;
+        return {
+            preserveInput: commandPaletteConfig.preserveInput,
+            experimental: commandPaletteConfig.experimental
+        };
+    }
+    updateSuggestedCommandIds(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.experimental.suggestCommands')) {
+            return;
+        }
+        const config = this.configuration;
+        const suggestedCommandIds = config.experimental.suggestCommands && this.productService.commandPaletteSuggestedCommandIds?.length
+            ? ( new Set(this.productService.commandPaletteSuggestedCommandIds))
+            : undefined;
+        this.options.suggestedCommandIds = suggestedCommandIds;
+    }
+    async getCommandPicks(token) {
+        await this.extensionRegistrationRace;
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        return ( [
+            ...this.getCodeEditorCommandPicks(),
+            ...this.getGlobalCommandPicks()
+        ].map(c => ({
+            ...c,
+            buttons: [{
+                    iconClass: ThemeIcon.asClassName(Codicon.gear),
+                    tooltip: ( localize('configure keybinding', "Configure Keybinding")),
+                }],
+            trigger: () => {
+                this.preferencesService.openGlobalKeybindingSettings(false, { query: `@command:${c.commandId}` });
+                return TriggerAction.CLOSE_PICKER;
+            },
+        })));
+    }
+    getGlobalCommandPicks() {
+        const globalCommandPicks = [];
+        const scopedContextKeyService = this.editorService.activeEditorPane?.scopedContextKeyService || this.editorGroupService.activeGroup.scopedContextKeyService;
+        const globalCommandsMenu = this.menuService.createMenu(MenuId.CommandPalette, scopedContextKeyService);
+        const globalCommandsMenuActions = globalCommandsMenu.getActions()
+            .reduce((r, [, actions]) => [...r, ...actions], [])
+            .filter(action => action instanceof MenuItemAction && action.enabled);
+        for (const action of globalCommandsMenuActions) {
+            let label = (typeof action.item.title === 'string' ? action.item.title : action.item.title.value) || action.item.id;
+            const category = typeof action.item.category === 'string' ? action.item.category : action.item.category?.value;
+            if (category) {
+                label = ( localize('commandWithCategory', "{0}: {1}", category, label));
+            }
+            const aliasLabel = typeof action.item.title !== 'string' ? action.item.title.original : undefined;
+            const aliasCategory = (category && action.item.category && typeof action.item.category !== 'string') ? action.item.category.original : undefined;
+            const commandAlias = (aliasLabel && category) ?
+                aliasCategory ? `${aliasCategory}: ${aliasLabel}` : `${category}: ${aliasLabel}` :
+                aliasLabel;
+            globalCommandPicks.push({
+                commandId: action.item.id,
+                commandAlias,
+                label: stripIcons(label)
+            });
+        }
+        globalCommandsMenu.dispose();
+        return globalCommandPicks;
+    }
+};
+CommandsQuickAccessProvider = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IMenuService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IDialogService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IEditorGroupsService)),
+    ( __param(10, IPreferencesService)),
+    ( __param(11, IProductService))
+], CommandsQuickAccessProvider));
+class ShowAllCommandsAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowAllCommandsAction.ID,
+            title: { value: ( localize('showTriggerActions', "Show All Commands")), original: 'Show All Commands' },
+            keybinding: {
+                weight: 200 ,
+                when: undefined,
+                primary: !isFirefox ? ((2048  | 1024  | 46) ) : undefined,
+                secondary: [59 ]
+            },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        accessor.get(IQuickInputService).quickAccess.show(CommandsQuickAccessProvider.PREFIX);
+    }
+}
+ShowAllCommandsAction.ID = 'workbench.action.showCommands';
+export { CommandsQuickAccessProvider, ShowAllCommandsAction };

package/dist/vscode/vs/workbench/contrib/search/common/search.js

@@ -0,0 +1,27 @@
+var WorkspaceSymbolProviderRegistry;
+( (function(WorkspaceSymbolProviderRegistry) {
+    const _supports = [];
+    function register(provider) {
+        let support = provider;
+        if (support) {
+            _supports.push(support);
+        }
+        return {
+            dispose() {
+                if (support) {
+                    const idx = _supports.indexOf(support);
+                    if (idx >= 0) {
+                        _supports.splice(idx, 1);
+                        support = undefined;
+                    }
+                }
+            }
+        };
+    }
+    WorkspaceSymbolProviderRegistry.register = register;
+    function all() {
+        return _supports.slice(0);
+    }
+    WorkspaceSymbolProviderRegistry.all = all;
+})(WorkspaceSymbolProviderRegistry || (WorkspaceSymbolProviderRegistry = {})));
+export { WorkspaceSymbolProviderRegistry };