@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/base/common/paging.js

@@ -0,0 +1,116 @@
+import { range } from './arrays.js';
+import { CancellationTokenSource } from './cancellation.js';
+import { CancellationError } from './errors.js';
+function createPage(elements) {
+    return {
+        isResolved: !!elements,
+        promise: null,
+        cts: null,
+        promiseIndexes: ( new Set()),
+        elements: elements || []
+    };
+}
+function singlePagePager(elements) {
+    return {
+        firstPage: elements,
+        total: elements.length,
+        pageSize: elements.length,
+        getPage: (pageIndex, cancellationToken) => {
+            return Promise.resolve(elements);
+        }
+    };
+}
+class PagedModel {
+    get length() { return this.pager.total; }
+    constructor(arg) {
+        this.pages = [];
+        this.pager = Array.isArray(arg) ? singlePagePager(arg) : arg;
+        const totalPages = Math.ceil(this.pager.total / this.pager.pageSize);
+        this.pages = [
+            createPage(this.pager.firstPage.slice()),
+            ...( range(totalPages - 1).map(() => createPage()))
+        ];
+    }
+    isResolved(index) {
+        const pageIndex = Math.floor(index / this.pager.pageSize);
+        const page = this.pages[pageIndex];
+        return !!page.isResolved;
+    }
+    get(index) {
+        const pageIndex = Math.floor(index / this.pager.pageSize);
+        const indexInPage = index % this.pager.pageSize;
+        const page = this.pages[pageIndex];
+        return page.elements[indexInPage];
+    }
+    resolve(index, cancellationToken) {
+        if (cancellationToken.isCancellationRequested) {
+            return Promise.reject(( new CancellationError()));
+        }
+        const pageIndex = Math.floor(index / this.pager.pageSize);
+        const indexInPage = index % this.pager.pageSize;
+        const page = this.pages[pageIndex];
+        if (page.isResolved) {
+            return Promise.resolve(page.elements[indexInPage]);
+        }
+        if (!page.promise) {
+            page.cts = ( new CancellationTokenSource());
+            page.promise = this.pager.getPage(pageIndex, page.cts.token)
+                .then(elements => {
+                page.elements = elements;
+                page.isResolved = true;
+                page.promise = null;
+                page.cts = null;
+            }, err => {
+                page.isResolved = false;
+                page.promise = null;
+                page.cts = null;
+                return Promise.reject(err);
+            });
+        }
+        const listener = cancellationToken.onCancellationRequested(() => {
+            if (!page.cts) {
+                return;
+            }
+            page.promiseIndexes.delete(index);
+            if (page.promiseIndexes.size === 0) {
+                page.cts.cancel();
+            }
+        });
+        page.promiseIndexes.add(index);
+        return page.promise.then(() => page.elements[indexInPage])
+            .finally(() => listener.dispose());
+    }
+}
+class DelayedPagedModel {
+    get length() { return this.model.length; }
+    constructor(model, timeout = 500) {
+        this.model = model;
+        this.timeout = timeout;
+    }
+    isResolved(index) {
+        return this.model.isResolved(index);
+    }
+    get(index) {
+        return this.model.get(index);
+    }
+    resolve(index, cancellationToken) {
+        return ( new Promise((c, e) => {
+            if (cancellationToken.isCancellationRequested) {
+                return e(( new CancellationError()));
+            }
+            const timer = setTimeout(() => {
+                if (cancellationToken.isCancellationRequested) {
+                    return e(( new CancellationError()));
+                }
+                timeoutCancellation.dispose();
+                this.model.resolve(index, cancellationToken).then(c, e);
+            }, this.timeout);
+            const timeoutCancellation = cancellationToken.onCancellationRequested(() => {
+                clearTimeout(timer);
+                timeoutCancellation.dispose();
+                e(( new CancellationError()));
+            });
+        }));
+    }
+}
+export { DelayedPagedModel, PagedModel, singlePagePager };

package/vscode/src/vs/base/common/parsers.js

@@ -0,0 +1,43 @@
+class ValidationStatus {
+    constructor() {
+        this._state = 0 ;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        if (value > this._state) {
+            this._state = value;
+        }
+    }
+    isOK() {
+        return this._state === 0 ;
+    }
+    isFatal() {
+        return this._state === 4 ;
+    }
+}
+class Parser {
+    constructor(problemReporter) {
+        this._problemReporter = problemReporter;
+    }
+    reset() {
+        this._problemReporter.status.state = 0 ;
+    }
+    get problemReporter() {
+        return this._problemReporter;
+    }
+    info(message) {
+        this._problemReporter.info(message);
+    }
+    warn(message) {
+        this._problemReporter.warn(message);
+    }
+    error(message) {
+        this._problemReporter.error(message);
+    }
+    fatal(message) {
+        this._problemReporter.fatal(message);
+    }
+}
+export { Parser, ValidationStatus };

package/vscode/src/vs/base/common/processes.js

@@ -0,0 +1,25 @@
+import './platform.js';
+function sanitizeProcessEnvironment(env, ...preserve) {
+    const set = preserve.reduce((set, key) => {
+        set[key] = true;
+        return set;
+    }, {});
+    const keysToRemove = [
+        /^ELECTRON_.+$/,
+        /^VSCODE_(?!(PORTABLE|SHELL_LOGIN|ENV_REPLACE|ENV_APPEND|ENV_PREPEND)).+$/,
+        /^SNAP(|_.*)$/,
+        /^GDK_PIXBUF_.+$/,
+    ];
+    const envKeys = ( Object.keys(env));
+    envKeys
+        .filter(key => !set[key])
+        .forEach(envKey => {
+        for (let i = 0; i < keysToRemove.length; i++) {
+            if (envKey.search(keysToRemove[i]) !== -1) {
+                delete env[envKey];
+                break;
+            }
+        }
+    });
+}
+export { sanitizeProcessEnvironment };

package/vscode/src/vs/base/parts/request/browser/request.js

@@ -0,0 +1,60 @@
+import { bufferToStream, VSBuffer } from '../../../common/buffer.js';
+import { canceled } from '../../../common/errors.js';
+import { OfflineError } from '../common/request.js';
+function request(options, token) {
+    if (options.proxyAuthorization) {
+        options.headers = {
+            ...(options.headers || {}),
+            'Proxy-Authorization': options.proxyAuthorization
+        };
+    }
+    const xhr = ( new XMLHttpRequest());
+    return ( new Promise((resolve, reject) => {
+        xhr.open(options.type || 'GET', options.url || '', true, options.user, options.password);
+        setRequestHeaders(xhr, options);
+        xhr.responseType = 'arraybuffer';
+        xhr.onerror = e => reject(navigator.onLine ? ( new Error(xhr.statusText && ('XHR failed: ' + xhr.statusText) || 'XHR failed')) : ( new OfflineError()));
+        xhr.onload = (e) => {
+            resolve({
+                res: {
+                    statusCode: xhr.status,
+                    headers: getResponseHeaders(xhr)
+                },
+                stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(xhr.response))))
+            });
+        };
+        xhr.ontimeout = e => reject(( new Error(`XHR timeout: ${options.timeout}ms`)));
+        if (options.timeout) {
+            xhr.timeout = options.timeout;
+        }
+        xhr.send(options.data);
+        token.onCancellationRequested(() => {
+            xhr.abort();
+            reject(canceled());
+        });
+    }));
+}
+function setRequestHeaders(xhr, options) {
+    if (options.headers) {
+        outer: for (const k in options.headers) {
+            switch (k) {
+                case 'User-Agent':
+                case 'Accept-Encoding':
+                case 'Content-Length':
+                    continue outer;
+            }
+            xhr.setRequestHeader(k, options.headers[k]);
+        }
+    }
+}
+function getResponseHeaders(xhr) {
+    const headers = Object.create(null);
+    for (const line of xhr.getAllResponseHeaders().split(/\r\n|\n|\r/g)) {
+        if (line) {
+            const idx = line.indexOf(':');
+            headers[line.substr(0, idx).trim().toLowerCase()] = line.substr(idx + 1).trim();
+        }
+    }
+    return headers;
+}
+export { request };

package/vscode/src/vs/editor/browser/coreCommands.js

@@ -2,7 +2,7 @@ import { localizeWithPath } from '../../nls.js';
 import { isFirefox } from '../../base/browser/browser.js';
 import { isObject, isString, isUndefined, isNumber, isBoolean } from '../../base/common/types.js';
 import { status } from '../../base/browser/ui/aria/aria.js';
-import { registerEditorCommand, SelectAllCommand, UndoCommand, RedoCommand, EditorCommand, Command } from './editorExtensions.js';
+import { registerEditorCommand, SelectAllCommand, EditorCommand, UndoCommand, RedoCommand, Command } from './editorExtensions.js';
 import { ICodeEditorService } from './services/codeEditorService.js';
 import { ColumnSelection } from '../common/cursor/cursorColumnSelection.js';
 import { CursorState } from '../common/cursorCommon.js';

package/vscode/src/vs/editor/common/services/modelUndoRedoParticipant.js

@@ -0,0 +1,56 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IModelService } from './model.js';
+import { ITextModelService } from './resolverService.js';
+import { Disposable, dispose } from '../../../base/common/lifecycle.js';
+import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.js';
+import { MultiModelEditStackElement } from '../model/editStack.js';
+let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable {
+    constructor(_modelService, _textModelService, _undoRedoService) {
+        super();
+        this._modelService = _modelService;
+        this._textModelService = _textModelService;
+        this._undoRedoService = _undoRedoService;
+        this._register(this._modelService.onModelRemoved((model) => {
+            const elements = this._undoRedoService.getElements(model.uri);
+            if (elements.past.length === 0 && elements.future.length === 0) {
+                return;
+            }
+            for (const element of elements.past) {
+                if (element instanceof MultiModelEditStackElement) {
+                    element.setDelegate(this);
+                }
+            }
+            for (const element of elements.future) {
+                if (element instanceof MultiModelEditStackElement) {
+                    element.setDelegate(this);
+                }
+            }
+        }));
+    }
+    prepareUndoRedo(element) {
+        const missingModels = element.getMissingModels();
+        if (missingModels.length === 0) {
+            return Disposable.None;
+        }
+        const disposablesPromises = ( missingModels.map(async (uri) => {
+            try {
+                const reference = await this._textModelService.createModelReference(uri);
+                return reference;
+            }
+            catch (err) {
+                return Disposable.None;
+            }
+        }));
+        return Promise.all(disposablesPromises).then(disposables => {
+            return {
+                dispose: () => dispose(disposables)
+            };
+        });
+    }
+};
+ModelUndoRedoParticipant = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, IUndoRedoService))
+], ModelUndoRedoParticipant));
+export { ModelUndoRedoParticipant };

package/vscode/src/vs/editor/common/services/textResourceConfigurationService.js

@@ -0,0 +1,116 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { Position } from '../core/position.js';
+import { ILanguageService } from '../languages/language.js';
+import { IModelService } from './model.js';
+import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
+let TextResourceConfigurationService = class TextResourceConfigurationService extends Disposable {
+    constructor(configurationService, modelService, languageService) {
+        super();
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._register(this.configurationService.onDidChangeConfiguration(e => this._onDidChangeConfiguration.fire(this.toResourceConfigurationChangeEvent(e))));
+    }
+    getValue(resource, arg2, arg3) {
+        if (typeof arg3 === 'string') {
+            return this._getValue(resource, Position.isIPosition(arg2) ? arg2 : null, arg3);
+        }
+        return this._getValue(resource, null, typeof arg2 === 'string' ? arg2 : undefined);
+    }
+    updateValue(resource, key, value, configurationTarget) {
+        const language = this.getLanguage(resource, null);
+        const configurationValue = this.configurationService.inspect(key, { resource, overrideIdentifier: language });
+        if (configurationTarget === undefined) {
+            configurationTarget = this.deriveConfigurationTarget(configurationValue, language);
+        }
+        switch (configurationTarget) {
+            case 8 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.memory?.override, resource, language);
+            case 6 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.workspaceFolder?.override, resource, language);
+            case 5 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.workspace?.override, resource, language);
+            case 4 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.userRemote?.override, resource, language);
+            default:
+                return this._updateValue(key, value, configurationTarget, configurationValue.userLocal?.override, resource, language);
+        }
+    }
+    _updateValue(key, value, configurationTarget, overriddenValue, resource, language) {
+        if (language && overriddenValue !== undefined) {
+            return this.configurationService.updateValue(key, value, { resource, overrideIdentifier: language }, configurationTarget);
+        }
+        else {
+            return this.configurationService.updateValue(key, value, { resource }, configurationTarget);
+        }
+    }
+    deriveConfigurationTarget(configurationValue, language) {
+        if (language) {
+            if (configurationValue.memory?.override !== undefined) {
+                return 8 ;
+            }
+            if (configurationValue.workspaceFolder?.override !== undefined) {
+                return 6 ;
+            }
+            if (configurationValue.workspace?.override !== undefined) {
+                return 5 ;
+            }
+            if (configurationValue.userRemote?.override !== undefined) {
+                return 4 ;
+            }
+            if (configurationValue.userLocal?.override !== undefined) {
+                return 3 ;
+            }
+        }
+        if (configurationValue.memory?.value !== undefined) {
+            return 8 ;
+        }
+        if (configurationValue.workspaceFolder?.value !== undefined) {
+            return 6 ;
+        }
+        if (configurationValue.workspace?.value !== undefined) {
+            return 5 ;
+        }
+        if (configurationValue.userRemote?.value !== undefined) {
+            return 4 ;
+        }
+        return 3 ;
+    }
+    _getValue(resource, position, section) {
+        const language = resource ? this.getLanguage(resource, position) : undefined;
+        if (typeof section === 'undefined') {
+            return this.configurationService.getValue({ resource, overrideIdentifier: language });
+        }
+        return this.configurationService.getValue(section, { resource, overrideIdentifier: language });
+    }
+    inspect(resource, position, section) {
+        const language = resource ? this.getLanguage(resource, position) : undefined;
+        return this.configurationService.inspect(section, { resource, overrideIdentifier: language });
+    }
+    getLanguage(resource, position) {
+        const model = this.modelService.getModel(resource);
+        if (model) {
+            return position ? model.getLanguageIdAtPosition(position.lineNumber, position.column) : model.getLanguageId();
+        }
+        return this.languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+    }
+    toResourceConfigurationChangeEvent(configurationChangeEvent) {
+        return {
+            affectedKeys: configurationChangeEvent.affectedKeys,
+            affectsConfiguration: (resource, configuration) => {
+                const overrideIdentifier = resource ? this.getLanguage(resource, null) : undefined;
+                return configurationChangeEvent.affectsConfiguration(configuration, { resource, overrideIdentifier });
+            }
+        };
+    }
+};
+TextResourceConfigurationService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageService))
+], TextResourceConfigurationService));
+export { TextResourceConfigurationService };

package/vscode/src/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js

@@ -0,0 +1,23 @@
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { AbstractCommandsQuickAccessProvider } from '../../../../platform/quickinput/browser/commandsQuickAccess.js';
+class AbstractEditorCommandsQuickAccessProvider extends AbstractCommandsQuickAccessProvider {
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(options, instantiationService, keybindingService, commandService, telemetryService, dialogService);
+    }
+    getCodeEditorCommandPicks() {
+        const activeTextEditorControl = this.activeTextEditorControl;
+        if (!activeTextEditorControl) {
+            return [];
+        }
+        const editorCommandPicks = [];
+        for (const editorAction of activeTextEditorControl.getSupportedActions()) {
+            editorCommandPicks.push({
+                commandId: editorAction.id,
+                commandAlias: editorAction.alias,
+                label: stripIcons(editorAction.label) || editorAction.id,
+            });
+        }
+        return editorCommandPicks;
+    }
+}
+export { AbstractEditorCommandsQuickAccessProvider };

package/vscode/src/vs/platform/debug/common/extensionHostDebugIpc.js

@@ -0,0 +1,71 @@
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+class ExtensionHostDebugBroadcastChannel {
+    constructor() {
+        this._onCloseEmitter = ( new Emitter());
+        this._onReloadEmitter = ( new Emitter());
+        this._onTerminateEmitter = ( new Emitter());
+        this._onAttachEmitter = ( new Emitter());
+    }
+    static { this.ChannelName = 'extensionhostdebugservice'; }
+    call(ctx, command, arg) {
+        switch (command) {
+            case 'close':
+                return Promise.resolve(this._onCloseEmitter.fire({ sessionId: arg[0] }));
+            case 'reload':
+                return Promise.resolve(this._onReloadEmitter.fire({ sessionId: arg[0] }));
+            case 'terminate':
+                return Promise.resolve(this._onTerminateEmitter.fire({ sessionId: arg[0] }));
+            case 'attach':
+                return Promise.resolve(this._onAttachEmitter.fire({ sessionId: arg[0], port: arg[1], subId: arg[2] }));
+        }
+        throw new Error('Method not implemented.');
+    }
+    listen(ctx, event, arg) {
+        switch (event) {
+            case 'close':
+                return this._onCloseEmitter.event;
+            case 'reload':
+                return this._onReloadEmitter.event;
+            case 'terminate':
+                return this._onTerminateEmitter.event;
+            case 'attach':
+                return this._onAttachEmitter.event;
+        }
+        throw new Error('Method not implemented.');
+    }
+}
+class ExtensionHostDebugChannelClient extends Disposable {
+    constructor(channel) {
+        super();
+        this.channel = channel;
+    }
+    reload(sessionId) {
+        this.channel.call('reload', [sessionId]);
+    }
+    get onReload() {
+        return this.channel.listen('reload');
+    }
+    close(sessionId) {
+        this.channel.call('close', [sessionId]);
+    }
+    get onClose() {
+        return this.channel.listen('close');
+    }
+    attachSession(sessionId, port, subId) {
+        this.channel.call('attach', [sessionId, port, subId]);
+    }
+    get onAttachSession() {
+        return this.channel.listen('attach');
+    }
+    terminateSession(sessionId, subId) {
+        this.channel.call('terminate', [sessionId, subId]);
+    }
+    get onTerminateSession() {
+        return this.channel.listen('terminate');
+    }
+    openExtensionDevelopmentHostWindow(args, debugRenderer) {
+        return this.channel.call('openExtensionDevelopmentHostWindow', [args, debugRenderer]);
+    }
+}
+export { ExtensionHostDebugBroadcastChannel, ExtensionHostDebugChannelClient };

package/vscode/src/vs/platform/download/common/downloadIpc.js

@@ -0,0 +1,16 @@
+import { URI } from '../../../base/common/uri.js';
+class DownloadServiceChannel {
+    constructor(service) {
+        this.service = service;
+    }
+    listen(_, event, arg) {
+        throw new Error('Invalid listen');
+    }
+    call(context, command, args) {
+        switch (command) {
+            case 'download': return this.service.download(URI.revive(args[0]), URI.revive(args[1]));
+        }
+        throw new Error('Invalid call');
+    }
+}
+export { DownloadServiceChannel };

package/vscode/src/vs/platform/download/common/downloadService.js

@@ -0,0 +1,31 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Schemas } from '../../../base/common/network.js';
+import { IFileService } from '../../files/common/files.js';
+import { asTextOrError, IRequestService } from '../../request/common/request.js';
+let DownloadService = class DownloadService {
+    constructor(requestService, fileService) {
+        this.requestService = requestService;
+        this.fileService = fileService;
+    }
+    async download(resource, target, cancellationToken = CancellationToken.None) {
+        if (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeRemote) {
+            await this.fileService.copy(resource, target);
+            return;
+        }
+        const options = { type: 'GET', url: ( resource.toString(true)) };
+        const context = await this.requestService.request(options, cancellationToken);
+        if (context.res.statusCode === 200) {
+            await this.fileService.writeFile(target, context.stream);
+        }
+        else {
+            const message = await asTextOrError(context);
+            throw new Error(`Expected 200, got back ${context.res.statusCode} instead.\n\n${message}`);
+        }
+    }
+};
+DownloadService = ( __decorate([
+    ( __param(0, IRequestService)),
+    ( __param(1, IFileService))
+], DownloadService));
+export { DownloadService };