@codingame/monaco-vscode-api 1.85.1 → 1.85.3

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistory.js

@@ -0,0 +1,4 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IWorkingCopyHistoryService = ( createDecorator('workingCopyHistoryService'));
+const MAX_PARALLEL_HISTORY_IO_OPS = 20;
+export { IWorkingCopyHistoryService, MAX_PARALLEL_HISTORY_IO_OPS };

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

@@ -1,60 +0,0 @@
-import { bufferToStream, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { canceled } from 'monaco-editor/esm/vs/base/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/platform/request/browser/requestService.js

@@ -1,28 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { request } from '../../../base/parts/request/browser/request.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { AbstractRequestService } from '../common/request.js';
-let RequestService = class RequestService extends AbstractRequestService {
-    constructor(configurationService, loggerService) {
-        super(loggerService);
-        this.configurationService = configurationService;
-    }
-    async request(options, token) {
-        if (!options.proxyAuthorization) {
-            options.proxyAuthorization = this.configurationService.getValue('http.proxyAuthorization');
-        }
-        return this.logAndRequest('browser', options, () => request(options, token));
-    }
-    async resolveProxy(url) {
-        return undefined;
-    }
-    async loadCertificates() {
-        return [];
-    }
-};
-RequestService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ILoggerService))
-], RequestService));
-export { RequestService };

package/vscode/src/vs/platform/request/common/requestIpc.js

@@ -1,17 +0,0 @@
-import { bufferToStream } from 'monaco-editor/esm/vs/base/common/buffer.js';
-class RequestChannelClient {
-    constructor(channel) {
-        this.channel = channel;
-    }
-    async request(options, token) {
-        const [res, buffer] = await this.channel.call('request', [options], token);
-        return { res, stream: bufferToStream(buffer) };
-    }
-    async resolveProxy(url) {
-        return this.channel.call('resolveProxy', [url]);
-    }
-    async loadCertificates() {
-        return this.channel.call('loadCertificates');
-    }
-}
-export { RequestChannelClient };

package/vscode/src/vs/platform/url/common/urlService.js

@@ -1,17 +0,0 @@
-import { first } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-class AbstractURLService extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.handlers = ( new Set());
-    }
-    open(uri, options) {
-        const handlers = [...( this.handlers.values())];
-        return first(( handlers.map(h => () => h.handleURL(uri, options))), undefined, false).then(val => val || false);
-    }
-    registerHandler(handler) {
-        this.handlers.add(handler);
-        return toDisposable(() => this.handlers.delete(handler));
-    }
-}
-export { AbstractURLService };

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -1,120 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as json from 'monaco-editor/esm/vs/base/common/json.js';
-import { setProperty } from '../../../../base/common/jsonEdit.js';
-import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
-import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
-import { ITextFileService } from '../../textfile/common/textfiles.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { JSONEditingError } from './jsonEditing.js';
-let JSONEditingService = class JSONEditingService {
-    constructor(fileService, textModelResolverService, textFileService) {
-        this.fileService = fileService;
-        this.textModelResolverService = textModelResolverService;
-        this.textFileService = textFileService;
-        this.queue = ( new Queue());
-    }
-    write(resource, values) {
-        return Promise.resolve(this.queue.queue(() => this.doWriteConfiguration(resource, values)));
-    }
-    async doWriteConfiguration(resource, values) {
-        const reference = await this.resolveAndValidate(resource, true);
-        try {
-            await this.writeToBuffer(reference.object.textEditorModel, values);
-        }
-        finally {
-            reference.dispose();
-        }
-    }
-    async writeToBuffer(model, values) {
-        let hasEdits = false;
-        for (const value of values) {
-            const edit = this.getEdits(model, value)[0];
-            hasEdits = !!edit && this.applyEditsToBuffer(edit, model);
-        }
-        if (hasEdits) {
-            return this.textFileService.save(model.uri);
-        }
-    }
-    applyEditsToBuffer(edit, model) {
-        const startPosition = model.getPositionAt(edit.offset);
-        const endPosition = model.getPositionAt(edit.offset + edit.length);
-        const range = ( new Range(
-            startPosition.lineNumber,
-            startPosition.column,
-            endPosition.lineNumber,
-            endPosition.column
-        ));
-        const currentText = model.getValueInRange(range);
-        if (edit.content !== currentText) {
-            const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
-            model.pushEditOperations([( new Selection(
-                startPosition.lineNumber,
-                startPosition.column,
-                startPosition.lineNumber,
-                startPosition.column
-            ))], [editOperation], () => []);
-            return true;
-        }
-        return false;
-    }
-    getEdits(model, configurationValue) {
-        const { tabSize, insertSpaces } = model.getOptions();
-        const eol = model.getEOL();
-        const { path, value } = configurationValue;
-        if (!path.length) {
-            const content = JSON.stringify(value, null, insertSpaces ? ' '.repeat(tabSize) : '\t');
-            return [{
-                    content,
-                    length: content.length,
-                    offset: 0
-                }];
-        }
-        return setProperty(model.getValue(), path, value, { tabSize, insertSpaces, eol });
-    }
-    async resolveModelReference(resource) {
-        const exists = await this.fileService.exists(resource);
-        if (!exists) {
-            await this.textFileService.write(resource, '{}', { encoding: 'utf8' });
-        }
-        return this.textModelResolverService.createModelReference(resource);
-    }
-    hasParseErrors(model) {
-        const parseErrors = [];
-        json.parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
-        return parseErrors.length > 0;
-    }
-    async resolveAndValidate(resource, checkDirty) {
-        const reference = await this.resolveModelReference(resource);
-        const model = reference.object.textEditorModel;
-        if (this.hasParseErrors(model)) {
-            reference.dispose();
-            return this.reject(0 );
-        }
-        return reference;
-    }
-    reject(code) {
-        const message = this.toErrorMessage(code);
-        return Promise.reject(( new JSONEditingError(message, code)));
-    }
-    toErrorMessage(error) {
-        switch (error) {
-            case 0 : {
-                return ( nls.localizeWithPath(
-                    'vs/workbench/services/configuration/common/jsonEditingService',
-                    'errorInvalidFile',
-                    "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
-                ));
-            }
-        }
-    }
-};
-JSONEditingService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ITextModelService)),
-    ( __param(2, ITextFileService))
-], JSONEditingService));
-export { JSONEditingService };

package/vscode/src/vs/workbench/services/decorations/browser/decorationsService.js

@@ -1,319 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DebounceEmitter, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
-import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isThenable } from 'monaco-editor/esm/vs/base/common/async.js';
-import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
-import { createCSSRule, asCSSPropertyValue, removeCSSRulesContainingSelector, createStyleSheet } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { distinct, asArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { asCssVariable } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-class DecorationRule {
-    static keyOf(data) {
-        if (Array.isArray(data)) {
-            return ( data.map(DecorationRule.keyOf)).join(',');
-        }
-        else {
-            const { color, letter } = data;
-            if (ThemeIcon.isThemeIcon(letter)) {
-                return `${color}+${letter.id}`;
-            }
-            else {
-                return `${color}/${letter}`;
-            }
-        }
-    }
-    static { this._classNamesPrefix = 'monaco-decoration'; }
-    constructor(themeService, data, key) {
-        this.themeService = themeService;
-        this._refCounter = 0;
-        this.data = data;
-        const suffix = ( hash(key).toString(36));
-        this.itemColorClassName = `${DecorationRule._classNamesPrefix}-itemColor-${suffix}`;
-        this.itemBadgeClassName = `${DecorationRule._classNamesPrefix}-itemBadge-${suffix}`;
-        this.bubbleBadgeClassName = `${DecorationRule._classNamesPrefix}-bubbleBadge-${suffix}`;
-        this.iconBadgeClassName = `${DecorationRule._classNamesPrefix}-iconBadge-${suffix}`;
-    }
-    acquire() {
-        this._refCounter += 1;
-    }
-    release() {
-        return --this._refCounter === 0;
-    }
-    appendCSSRules(element) {
-        if (!Array.isArray(this.data)) {
-            this._appendForOne(this.data, element);
-        }
-        else {
-            this._appendForMany(this.data, element);
-        }
-    }
-    _appendForOne(data, element) {
-        const { color, letter } = data;
-        createCSSRule(`.${this.itemColorClassName}`, `color: ${getColor(color)};`, element);
-        if (ThemeIcon.isThemeIcon(letter)) {
-            this._createIconCSSRule(letter, color, element);
-        }
-        else if (letter) {
-            createCSSRule(`.${this.itemBadgeClassName}::after`, `content: "${letter}"; color: ${getColor(color)};`, element);
-        }
-    }
-    _appendForMany(data, element) {
-        const { color } = data[0];
-        createCSSRule(`.${this.itemColorClassName}`, `color: ${getColor(color)};`, element);
-        const letters = [];
-        let icon;
-        for (const d of data) {
-            if (ThemeIcon.isThemeIcon(d.letter)) {
-                icon = d.letter;
-                break;
-            }
-            else if (d.letter) {
-                letters.push(d.letter);
-            }
-        }
-        if (icon) {
-            this._createIconCSSRule(icon, color, element);
-        }
-        else {
-            if (letters.length) {
-                createCSSRule(`.${this.itemBadgeClassName}::after`, `content: "${letters.join(', ')}"; color: ${getColor(color)};`, element);
-            }
-            createCSSRule(`.${this.bubbleBadgeClassName}::after`, `content: "\uea71"; color: ${getColor(color)}; font-family: codicon; font-size: 14px; margin-right: 14px; opacity: 0.4;`, element);
-        }
-    }
-    _createIconCSSRule(icon, color, element) {
-        const modifier = ThemeIcon.getModifier(icon);
-        if (modifier) {
-            icon = ThemeIcon.modify(icon, undefined);
-        }
-        const iconContribution = getIconRegistry().getIcon(icon.id);
-        if (!iconContribution) {
-            return;
-        }
-        const definition = this.themeService.getProductIconTheme().getIcon(iconContribution);
-        if (!definition) {
-            return;
-        }
-        createCSSRule(`.${this.iconBadgeClassName}::after`, `content: '${definition.fontCharacter}';
-			color: ${icon.color ? getColor(icon.color.id) : getColor(color)};
-			font-family: ${asCSSPropertyValue(definition.font?.id ?? 'codicon')};
-			font-size: 16px;
-			margin-right: 14px;
-			font-weight: normal;
-			${modifier === 'spin' ? 'animation: codicon-spin 1.5s steps(30) infinite' : ''};
-			`, element);
-    }
-    removeCSSRules(element) {
-        removeCSSRulesContainingSelector(this.itemColorClassName, element);
-        removeCSSRulesContainingSelector(this.itemBadgeClassName, element);
-        removeCSSRulesContainingSelector(this.bubbleBadgeClassName, element);
-        removeCSSRulesContainingSelector(this.iconBadgeClassName, element);
-    }
-}
-class DecorationStyles {
-    constructor(_themeService) {
-        this._themeService = _themeService;
-        this._dispoables = ( new DisposableStore());
-        this._styleElement = createStyleSheet(undefined, undefined, this._dispoables);
-        this._decorationRules = ( new Map());
-    }
-    dispose() {
-        this._dispoables.dispose();
-    }
-    asDecoration(data, onlyChildren) {
-        data.sort((a, b) => (b.weight || 0) - (a.weight || 0));
-        const key = DecorationRule.keyOf(data);
-        let rule = this._decorationRules.get(key);
-        if (!rule) {
-            rule = ( new DecorationRule(this._themeService, data, key));
-            this._decorationRules.set(key, rule);
-            rule.appendCSSRules(this._styleElement);
-        }
-        rule.acquire();
-        const labelClassName = rule.itemColorClassName;
-        let badgeClassName = rule.itemBadgeClassName;
-        const iconClassName = rule.iconBadgeClassName;
-        let tooltip = distinct(( data.filter(d => !isFalsyOrWhitespace(d.tooltip)).map(d => d.tooltip))).join(' • ');
-        const strikethrough = ( data.some(d => d.strikethrough));
-        if (onlyChildren) {
-            badgeClassName = rule.bubbleBadgeClassName;
-            tooltip = ( localizeWithPath(
-                'vs/workbench/services/decorations/browser/decorationsService',
-                'bubbleTitle',
-                "Contains emphasized items"
-            ));
-        }
-        return {
-            labelClassName,
-            badgeClassName,
-            iconClassName,
-            strikethrough,
-            tooltip,
-            dispose: () => {
-                if (rule?.release()) {
-                    this._decorationRules.delete(key);
-                    rule.removeCSSRules(this._styleElement);
-                    rule = undefined;
-                }
-            }
-        };
-    }
-}
-class FileDecorationChangeEvent {
-    constructor(all) {
-        this._data = TernarySearchTree.forUris(_uri => true);
-        this._data.fill(true, asArray(all));
-    }
-    affectsResource(uri) {
-        return this._data.hasElementOrSubtree(uri);
-    }
-}
-class DecorationDataRequest {
-    constructor(source, thenable) {
-        this.source = source;
-        this.thenable = thenable;
-    }
-}
-function getColor(color) {
-    return color ? asCssVariable(color) : 'inherit';
-}
-let DecorationsService = class DecorationsService {
-    constructor(uriIdentityService, themeService) {
-        this._onDidChangeDecorationsDelayed = ( new DebounceEmitter({ merge: all => all.flat() }));
-        this._onDidChangeDecorations = ( new Emitter());
-        this.onDidChangeDecorations = this._onDidChangeDecorations.event;
-        this._provider = ( new LinkedList());
-        this._decorationStyles = ( new DecorationStyles(themeService));
-        this._data = TernarySearchTree.forUris(key => uriIdentityService.extUri.ignorePathCasing(key));
-        this._onDidChangeDecorationsDelayed.event(event => { this._onDidChangeDecorations.fire(( new FileDecorationChangeEvent(event))); });
-    }
-    dispose() {
-        this._onDidChangeDecorations.dispose();
-        this._onDidChangeDecorationsDelayed.dispose();
-        this._data.clear();
-    }
-    registerDecorationsProvider(provider) {
-        const rm = this._provider.unshift(provider);
-        this._onDidChangeDecorations.fire({
-            affectsResource() { return true; }
-        });
-        const removeAll = () => {
-            const uris = [];
-            for (const [uri, map] of this._data) {
-                if (map.delete(provider)) {
-                    uris.push(uri);
-                }
-            }
-            if (uris.length > 0) {
-                this._onDidChangeDecorationsDelayed.fire(uris);
-            }
-        };
-        const listener = provider.onDidChange(uris => {
-            if (!uris) {
-                removeAll();
-            }
-            else {
-                for (const uri of uris) {
-                    const map = this._ensureEntry(uri);
-                    this._fetchData(map, uri, provider);
-                }
-            }
-        });
-        return toDisposable(() => {
-            rm();
-            listener.dispose();
-            removeAll();
-        });
-    }
-    _ensureEntry(uri) {
-        let map = this._data.get(uri);
-        if (!map) {
-            map = ( new Map());
-            this._data.set(uri, map);
-        }
-        return map;
-    }
-    getDecoration(uri, includeChildren) {
-        const all = [];
-        let containsChildren = false;
-        const map = this._ensureEntry(uri);
-        for (const provider of this._provider) {
-            let data = map.get(provider);
-            if (data === undefined) {
-                data = this._fetchData(map, uri, provider);
-            }
-            if (data && !(data instanceof DecorationDataRequest)) {
-                all.push(data);
-            }
-        }
-        if (includeChildren) {
-            const iter = this._data.findSuperstr(uri);
-            if (iter) {
-                for (const tuple of iter) {
-                    for (const data of ( tuple[1].values())) {
-                        if (data && !(data instanceof DecorationDataRequest)) {
-                            if (data.bubble) {
-                                all.push(data);
-                                containsChildren = true;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return all.length === 0
-            ? undefined
-            : this._decorationStyles.asDecoration(all, containsChildren);
-    }
-    _fetchData(map, uri, provider) {
-        const pendingRequest = map.get(provider);
-        if (pendingRequest instanceof DecorationDataRequest) {
-            pendingRequest.source.cancel();
-            map.delete(provider);
-        }
-        const cts = ( new CancellationTokenSource());
-        const dataOrThenable = provider.provideDecorations(uri, cts.token);
-        if (!isThenable(dataOrThenable)) {
-            cts.dispose();
-            return this._keepItem(map, provider, uri, dataOrThenable);
-        }
-        else {
-            const request = ( new DecorationDataRequest(cts, Promise.resolve(dataOrThenable).then(data => {
-                if (map.get(provider) === request) {
-                    this._keepItem(map, provider, uri, data);
-                }
-            }).catch(err => {
-                if (!isCancellationError(err) && map.get(provider) === request) {
-                    map.delete(provider);
-                }
-            }).finally(() => {
-                cts.dispose();
-            })));
-            map.set(provider, request);
-            return null;
-        }
-    }
-    _keepItem(map, provider, uri, data) {
-        const deco = data ? data : null;
-        const old = map.get(provider);
-        map.set(provider, deco);
-        if (deco || old) {
-            this._onDidChangeDecorationsDelayed.fire(uri);
-        }
-        return deco;
-    }
-};
-DecorationsService = ( __decorate([
-    ( __param(0, IUriIdentityService)),
-    ( __param(1, IThemeService))
-], DecorationsService));
-export { DecorationsService };

package/vscode/src/vs/workbench/services/files/browser/elevatedFileService.js

@@ -1,9 +0,0 @@
-class BrowserElevatedFileService {
-    isSupported(resource) {
-        return false;
-    }
-    async writeFileElevated(resource, value, options) {
-        throw new Error('Unsupported');
-    }
-}
-export { BrowserElevatedFileService };