@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

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

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/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 });
+    }
+    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/dist/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem.js

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { BaseActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+let DropdownWithPrimaryActionViewItem = class DropdownWithPrimaryActionViewItem extends BaseActionViewItem {
+    get onDidChangeDropdownVisibility() {
+        return this._dropdown.onDidChangeVisibility;
+    }
+    constructor(primaryAction, dropdownAction, dropdownMenuActions, className, _contextMenuProvider, _options, _keybindingService, _notificationService, _contextKeyService, _themeService) {
+        super(null, primaryAction);
+        this._contextMenuProvider = _contextMenuProvider;
+        this._options = _options;
+        this._container = null;
+        this._dropdownContainer = null;
+        this._primaryAction = ( new MenuEntryActionViewItem(
+            primaryAction,
+            undefined,
+            _keybindingService,
+            _notificationService,
+            _contextKeyService,
+            _themeService,
+            _contextMenuProvider
+        ));
+        this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
+            menuAsChild: true,
+            classNames: className ? ['codicon', 'codicon-chevron-down', className] : ['codicon', 'codicon-chevron-down'],
+            keybindingProvider: this._options?.getKeyBinding
+        }));
+    }
+    setActionContext(newContext) {
+        super.setActionContext(newContext);
+        this._primaryAction.setActionContext(newContext);
+        this._dropdown.setActionContext(newContext);
+    }
+    render(container) {
+        this._container = container;
+        super.render(this._container);
+        this._container.classList.add('monaco-dropdown-with-primary');
+        const primaryContainer = dom.$('.action-container');
+        this._primaryAction.render(dom.append(this._container, primaryContainer));
+        this._dropdownContainer = dom.$('.dropdown-action-container');
+        this._dropdown.render(dom.append(this._container, this._dropdownContainer));
+        this._register(dom.addDisposableListener(primaryContainer, dom.EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(17 )) {
+                this._primaryAction.element.tabIndex = -1;
+                this._dropdown.focus();
+                event.stopPropagation();
+            }
+        }));
+        this._register(dom.addDisposableListener(this._dropdownContainer, dom.EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(15 )) {
+                this._primaryAction.element.tabIndex = 0;
+                this._dropdown.setFocusable(false);
+                this._primaryAction.element?.focus();
+                event.stopPropagation();
+            }
+        }));
+    }
+    focus(fromRight) {
+        if (fromRight) {
+            this._dropdown.focus();
+        }
+        else {
+            this._primaryAction.element.tabIndex = 0;
+            this._primaryAction.element.focus();
+        }
+    }
+    blur() {
+        this._primaryAction.element.tabIndex = -1;
+        this._dropdown.blur();
+        this._container.blur();
+    }
+    setFocusable(focusable) {
+        if (focusable) {
+            this._primaryAction.element.tabIndex = 0;
+        }
+        else {
+            this._primaryAction.element.tabIndex = -1;
+            this._dropdown.setFocusable(false);
+        }
+    }
+    update(dropdownAction, dropdownMenuActions, dropdownIcon) {
+        this._dropdown.dispose();
+        this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
+            menuAsChild: true,
+            classNames: ['codicon', dropdownIcon || 'codicon-chevron-down']
+        }));
+        if (this._dropdownContainer) {
+            this._dropdown.render(this._dropdownContainer);
+        }
+    }
+    dispose() {
+        this._primaryAction.dispose();
+        this._dropdown.dispose();
+        super.dispose();
+    }
+};
+DropdownWithPrimaryActionViewItem = ( __decorate([
+    ( __param(6, IKeybindingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IThemeService))
+], DropdownWithPrimaryActionViewItem));
+export { DropdownWithPrimaryActionViewItem };

package/dist/vscode/vs/platform/debug/common/extensionHostDebug.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IExtensionHostDebugService = ( createDecorator('extensionHostDebugService'));
+export { IExtensionHostDebugService };

package/dist/{extensionManagement.js → vscode/vs/platform/extensionManagement/common/extensionManagement.js}

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const EXTENSION_IDENTIFIER_PATTERN = '^([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$';
 const IExtensionGalleryService = ( createDecorator('extensionGalleryService'));
-export { EXTENSION_IDENTIFIER_PATTERN, IExtensionGalleryService };
+const IExtensionManagementService = ( createDecorator('extensionManagementService'));
+export { EXTENSION_IDENTIFIER_PATTERN, IExtensionGalleryService, IExtensionManagementService };

package/dist/vscode/vs/platform/extensionManagement/common/extensionManagementUtil.js

@@ -0,0 +1,14 @@
+import { compareIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+function areSameExtensions(a, b) {
+    if (a.uuid && b.uuid) {
+        return a.uuid === b.uuid;
+    }
+    if (a.id === b.id) {
+        return true;
+    }
+    return compareIgnoreCase(a.id, b.id) === 0;
+}
+function getExtensionId(publisher, name) {
+    return `${publisher}.${name}`;
+}
+export { areSameExtensions, getExtensionId };

package/dist/vscode/vs/platform/extensionManagement/common/extensionNls.js

@@ -0,0 +1,66 @@
+import { isString, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+function localizeManifest(extensionManifest, translations, fallbackTranslations) {
+    try {
+        replaceNLStrings(extensionManifest, translations, fallbackTranslations);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+    }
+    return extensionManifest;
+}
+function replaceNLStrings(extensionManifest, messages, originalMessages) {
+    const processEntry = (obj, key, command) => {
+        const value = obj[key];
+        if (isString(value)) {
+            const str = value;
+            const length = str.length;
+            if (length > 1 && str[0] === '%' && str[length - 1] === '%') {
+                const messageKey = str.substr(1, length - 2);
+                let translated = messages[messageKey];
+                if (translated === undefined && originalMessages) {
+                    translated = originalMessages[messageKey];
+                }
+                const message = typeof translated === 'string' ? translated : translated?.message;
+                const original = originalMessages?.[messageKey];
+                const originalMessage = typeof original === 'string' ? original : original?.message;
+                if (!message) {
+                    if (!originalMessage) {
+                        console.warn(`[${extensionManifest.name}]: ${( ( localize('missingNLSKey', "Couldn't find message for key {0}.", messageKey)))}`);
+                    }
+                    return;
+                }
+                if (
+                command && (key === 'title' || key === 'category') &&
+                    originalMessage && originalMessage !== message) {
+                    const localizedString = {
+                        value: message,
+                        original: originalMessage
+                    };
+                    obj[key] = localizedString;
+                }
+                else {
+                    obj[key] = message;
+                }
+            }
+        }
+        else if (isObject(value)) {
+            for (const k in value) {
+                if (value.hasOwnProperty(k)) {
+                    k === 'commands' ? processEntry(value, k, true) : processEntry(value, k, command);
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                processEntry(value, i, command);
+            }
+        }
+    };
+    for (const key in extensionManifest) {
+        if (extensionManifest.hasOwnProperty(key)) {
+            processEntry(extensionManifest, key);
+        }
+    }
+}
+export { localizeManifest };

package/dist/vscode/vs/platform/extensionManagement/common/implicitActivationEvents.js

@@ -0,0 +1,53 @@
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+class ImplicitActivationEventsImpl {
+    constructor() {
+        this._generators = ( new Map());
+        this._cache = ( new WeakMap());
+    }
+    register(extensionPointName, generator) {
+        this._generators.set(extensionPointName, generator);
+    }
+    readActivationEvents(extensionDescription) {
+        if (!this._cache.has(extensionDescription)) {
+            this._cache.set(extensionDescription, this._readActivationEvents(extensionDescription));
+        }
+        return this._cache.get(extensionDescription);
+    }
+    createActivationEventsMap(extensionDescriptions) {
+        const result = Object.create(null);
+        for (const extensionDescription of extensionDescriptions) {
+            const activationEvents = this.readActivationEvents(extensionDescription);
+            if (activationEvents.length > 0) {
+                result[ExtensionIdentifier.toKey(extensionDescription.identifier)] = activationEvents;
+            }
+        }
+        return result;
+    }
+    _readActivationEvents(desc) {
+        if (typeof desc.main === 'undefined' && typeof desc.browser === 'undefined') {
+            return [];
+        }
+        const activationEvents = (Array.isArray(desc.activationEvents) ? desc.activationEvents.slice(0) : []);
+        if (!desc.contributes) {
+            return activationEvents;
+        }
+        for (const extPointName in desc.contributes) {
+            const generator = this._generators.get(extPointName);
+            if (!generator) {
+                continue;
+            }
+            const contrib = desc.contributes[extPointName];
+            const contribArr = Array.isArray(contrib) ? contrib : [contrib];
+            try {
+                generator(contribArr, activationEvents);
+            }
+            catch (err) {
+                onUnexpectedError(err);
+            }
+        }
+        return activationEvents;
+    }
+}
+const ImplicitActivationEvents = ( new ImplicitActivationEventsImpl());
+export { ImplicitActivationEvents, ImplicitActivationEventsImpl };

package/dist/vscode/vs/platform/extensionResourceLoader/common/extensionResourceLoader.js

@@ -0,0 +1,69 @@
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { format2 } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { getServiceMachineId } from '../../externalServices/common/serviceMachineId.js';
+import { supportsTelemetry, getTelemetryLevel } from '../../telemetry/common/telemetryUtils.js';
+import { RemoteAuthorities } from 'monaco-editor/esm/vs/base/common/network.js';
+import { getRemoteServerRootPath } from '../../remote/common/remoteHosts.js';
+const WEB_EXTENSION_RESOURCE_END_POINT = 'web-extension-resource';
+const IExtensionResourceLoaderService = ( createDecorator('extensionResourceLoaderService'));
+class AbstractExtensionResourceLoaderService {
+    constructor(_fileService, _storageService, _productService, _environmentService, _configurationService) {
+        this._fileService = _fileService;
+        this._storageService = _storageService;
+        this._productService = _productService;
+        this._environmentService = _environmentService;
+        this._configurationService = _configurationService;
+        this._webExtensionResourceEndPoint = `${getRemoteServerRootPath(_productService)}/${WEB_EXTENSION_RESOURCE_END_POINT}/`;
+        if (_productService.extensionsGallery) {
+            this._extensionGalleryResourceUrlTemplate = _productService.extensionsGallery.resourceUrlTemplate;
+            this._extensionGalleryAuthority = this._extensionGalleryResourceUrlTemplate ? this._getExtensionGalleryAuthority(( URI.parse(this._extensionGalleryResourceUrlTemplate))) : undefined;
+        }
+    }
+    get supportsExtensionGalleryResources() {
+        return this._extensionGalleryResourceUrlTemplate !== undefined;
+    }
+    getExtensionGalleryResourceURL(galleryExtension, path) {
+        if (this._extensionGalleryResourceUrlTemplate) {
+            const uri = ( URI.parse(
+                format2(this._extensionGalleryResourceUrlTemplate, { publisher: galleryExtension.publisher, name: galleryExtension.name, version: galleryExtension.version, path: 'extension' })
+            ));
+            return this._isWebExtensionResourceEndPoint(uri) ? uri.with({ scheme: RemoteAuthorities.getPreferredWebSchema() }) : uri;
+        }
+        return undefined;
+    }
+    isExtensionGalleryResource(uri) {
+        return this._extensionGalleryAuthority && this._extensionGalleryAuthority === this._getExtensionGalleryAuthority(uri);
+    }
+    async getExtensionGalleryRequestHeaders() {
+        const headers = {
+            'X-Client-Name': `${this._productService.applicationName}${isWeb ? '-web' : ''}`,
+            'X-Client-Version': this._productService.version
+        };
+        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
+            headers['X-Machine-Id'] = await this._getServiceMachineId();
+        }
+        if (this._productService.commit) {
+            headers['X-Client-Commit'] = this._productService.commit;
+        }
+        return headers;
+    }
+    _getServiceMachineId() {
+        if (!this._serviceMachineIdPromise) {
+            this._serviceMachineIdPromise = getServiceMachineId(this._environmentService, this._fileService, this._storageService);
+        }
+        return this._serviceMachineIdPromise;
+    }
+    _getExtensionGalleryAuthority(uri) {
+        if (this._isWebExtensionResourceEndPoint(uri)) {
+            return uri.authority;
+        }
+        const index = uri.authority.indexOf('.');
+        return index !== -1 ? uri.authority.substring(index + 1) : undefined;
+    }
+    _isWebExtensionResourceEndPoint(uri) {
+        return uri.path.startsWith(this._webExtensionResourceEndPoint);
+    }
+}
+export { AbstractExtensionResourceLoaderService, IExtensionResourceLoaderService };

package/dist/vscode/vs/platform/externalServices/common/serviceMachineId.js

@@ -0,0 +1,27 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { isUUID, generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+async function getServiceMachineId(environmentService, fileService, storageService) {
+    let uuid = storageService ? storageService.get('storage.serviceMachineId', -1 ) || null : null;
+    if (uuid) {
+        return uuid;
+    }
+    try {
+        const contents = await fileService.readFile(environmentService.serviceMachineIdResource);
+        const value = ( contents.value.toString());
+        uuid = isUUID(value) ? value : null;
+    }
+    catch (e) {
+        uuid = null;
+    }
+    if (!uuid) {
+        uuid = generateUuid();
+        try {
+            await fileService.writeFile(environmentService.serviceMachineIdResource, VSBuffer.fromString(uuid));
+        }
+        catch (error) {
+        }
+    }
+    storageService?.store('storage.serviceMachineId', uuid, -1 , 1 );
+    return uuid;
+}
+export { getServiceMachineId };