@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -5,43 +5,50 @@ import { DisposableStore } from '../../../base/common/lifecycle.js';
 import { MenuRegistry, isIMenuItem, MenuItemAction, SubmenuItemAction, isISubmenuItem } from './actions.js';
 import { ICommandService } from '../../commands/common/commands.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
-import { Separator, toAction } from '../../../base/common/actions.js';
+import { toAction, Separator } from '../../../base/common/actions.js';
 import { IStorageService } from '../../storage/common/storage.service.js';
 import { removeFastWithoutKeepingOrder } from '../../../base/common/arrays.js';
 import { localizeWithPath } from '../../../nls.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 var PersistedMenuHideState_1, MenuInfo_1;
+const _moduleId = "vs/platform/actions/common/menuService";
 let MenuService = class MenuService {
-    constructor(_commandService, storageService) {
+    constructor(_commandService, _keybindingService, storageService) {
         this._commandService = _commandService;
-        this._hiddenStates = ( new PersistedMenuHideState(storageService));
+        this._keybindingService = _keybindingService;
+        this._hiddenStates = ( (new PersistedMenuHideState(storageService)));
     }
     createMenu(id, contextKeyService, options) {
-        return ( new MenuImpl(
-            id,
-            this._hiddenStates,
-            { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options },
-            this._commandService,
-            contextKeyService
-        ));
+        return (
+             (new MenuImpl(
+                id,
+                this._hiddenStates,
+                { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options },
+                this._commandService,
+                this._keybindingService,
+                contextKeyService
+            ))
+        );
     }
     resetHiddenStates(ids) {
         this._hiddenStates.reset(ids);
     }
 };
-MenuService = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, IStorageService))
-], MenuService));
+MenuService = ( (__decorate([
+    ( (__param(0, ICommandService))),
+    ( (__param(1, IKeybindingService))),
+    ( (__param(2, IStorageService)))
+], MenuService)));
 let PersistedMenuHideState = class PersistedMenuHideState {
     static { PersistedMenuHideState_1 = this; }
     static { this._key = 'menu.hiddenCommands'; }
     constructor(_storageService) {
         this._storageService = _storageService;
-        this._disposables = ( new DisposableStore());
-        this._onDidChange = ( new Emitter());
+        this._disposables = ( (new DisposableStore()));
+        this._onDidChange = ( (new Emitter()));
         this.onDidChange = this._onDidChange.event;
         this._ignoreChangeEvent = false;
-        this._hiddenByDefaultCache = ( new Map());
+        this._hiddenByDefaultCache = ( (new Map()));
         try {
             const raw = _storageService.get(PersistedMenuHideState_1._key, 0 , '{}');
             this._data = JSON.parse(raw);
@@ -132,20 +139,21 @@ let PersistedMenuHideState = class PersistedMenuHideState {
         }
     }
 };
-PersistedMenuHideState = PersistedMenuHideState_1 = ( __decorate([
-    ( __param(0, IStorageService))
-], PersistedMenuHideState));
+PersistedMenuHideState = PersistedMenuHideState_1 = ( (__decorate([
+    ( (__param(0, IStorageService)))
+], PersistedMenuHideState)));
 let MenuInfo = MenuInfo_1 = class MenuInfo {
-    constructor(_id, _hiddenStates, _collectContextKeysForSubmenus, _commandService, _contextKeyService) {
+    constructor(_id, _hiddenStates, _collectContextKeysForSubmenus, _commandService, _keybindingService, _contextKeyService) {
         this._id = _id;
         this._hiddenStates = _hiddenStates;
         this._collectContextKeysForSubmenus = _collectContextKeysForSubmenus;
         this._commandService = _commandService;
+        this._keybindingService = _keybindingService;
         this._contextKeyService = _contextKeyService;
         this._menuGroups = [];
-        this._structureContextKeys = ( new Set());
-        this._preconditionContextKeys = ( new Set());
-        this._toggledContextKeys = ( new Set());
+        this._structureContextKeys = ( (new Set()));
+        this._preconditionContextKeys = ( (new Set()));
+        this._toggledContextKeys = ( (new Set()));
         this.refresh();
     }
     get structureContextKeys() {
@@ -203,26 +211,29 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
                     }
                     const menuHide = createMenuHide(this._id, isMenuItem ? item.command : item, this._hiddenStates);
                     if (isMenuItem) {
-                        activeActions.push(( new MenuItemAction(
+                        const menuKeybinding = createConfigureKeybindingAction(item.command.id, item.when, this._commandService, this._keybindingService);
+                        activeActions.push(( (new MenuItemAction(
                             item.command,
                             item.alt,
                             options,
                             menuHide,
+                            menuKeybinding,
                             this._contextKeyService,
                             this._commandService
-                        )));
+                        ))));
                     }
                     else {
-                        const groups = ( new MenuInfo_1(
+                        const groups = ( (new MenuInfo_1(
                             item.submenu,
                             this._hiddenStates,
                             this._collectContextKeysForSubmenus,
                             this._commandService,
+                            this._keybindingService,
                             this._contextKeyService
-                        )).createActionGroups(options);
-                        const submenuActions = Separator.join(...( groups.map(g => g[1])));
+                        ))).createActionGroups(options);
+                        const submenuActions = Separator.join(...( (groups.map(g => g[1]))));
                         if (submenuActions.length > 0) {
-                            activeActions.push(( new SubmenuItemAction(item, menuHide, submenuActions)));
+                            activeActions.push(( (new SubmenuItemAction(item, menuHide, submenuActions))));
                         }
                     }
                 }
@@ -235,7 +246,7 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
     }
     static _fillInKbExprKeys(exp, set) {
         if (exp) {
-            for (const key of ( exp.keys())) {
+            for (const key of ( (exp.keys()))) {
                 set.add(key);
             }
         }
@@ -277,31 +288,33 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
         return aStr.localeCompare(bStr);
     }
 };
-MenuInfo = MenuInfo_1 = ( __decorate([
-    ( __param(3, ICommandService)),
-    ( __param(4, IContextKeyService))
-], MenuInfo));
+MenuInfo = MenuInfo_1 = ( (__decorate([
+    ( (__param(3, ICommandService))),
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, IContextKeyService)))
+], MenuInfo)));
 let MenuImpl = class MenuImpl {
-    constructor(id, hiddenStates, options, commandService, contextKeyService) {
-        this._disposables = ( new DisposableStore());
-        this._menuInfo = ( new MenuInfo(
+    constructor(id, hiddenStates, options, commandService, keybindingService, contextKeyService) {
+        this._disposables = ( (new DisposableStore()));
+        this._menuInfo = ( (new MenuInfo(
             id,
             hiddenStates,
             options.emitEventsForSubmenuChanges,
             commandService,
+            keybindingService,
             contextKeyService
-        ));
-        const rebuildMenuSoon = ( new RunOnceScheduler(() => {
+        )));
+        const rebuildMenuSoon = ( (new RunOnceScheduler(() => {
             this._menuInfo.refresh();
             this._onDidChange.fire({ menu: this, isStructuralChange: true, isEnablementChange: true, isToggleChange: true });
-        }, options.eventDebounceDelay));
+        }, options.eventDebounceDelay)));
         this._disposables.add(rebuildMenuSoon);
         this._disposables.add(MenuRegistry.onDidChangeMenu(e => {
-            if (( e.has(id))) {
+            if (( (e.has(id)))) {
                 rebuildMenuSoon.schedule();
             }
         }));
-        const lazyListener = this._disposables.add(( new DisposableStore()));
+        const lazyListener = this._disposables.add(( (new DisposableStore())));
         const merge = (events) => {
             let isStructuralChange = false;
             let isEnablementChange = false;
@@ -329,12 +342,12 @@ let MenuImpl = class MenuImpl {
                 this._onDidChange.fire({ menu: this, isStructuralChange: true, isEnablementChange: false, isToggleChange: false });
             }));
         };
-        this._onDidChange = ( new DebounceEmitter({
+        this._onDidChange = ( (new DebounceEmitter({
             onWillAddFirstListener: startLazyListener,
             onDidRemoveLastListener: lazyListener.clear.bind(lazyListener),
             delay: options.eventDebounceDelay,
             merge
-        }));
+        })));
         this.onDidChange = this._onDidChange.event;
     }
     getActions(options) {
@@ -345,21 +358,17 @@ let MenuImpl = class MenuImpl {
         this._onDidChange.dispose();
     }
 };
-MenuImpl = ( __decorate([
-    ( __param(3, ICommandService)),
-    ( __param(4, IContextKeyService))
-], MenuImpl));
+MenuImpl = ( (__decorate([
+    ( (__param(3, ICommandService))),
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, IContextKeyService)))
+], MenuImpl)));
 function createMenuHide(menu, command, states) {
     const id = isISubmenuItem(command) ? command.submenu.id : command.id;
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localizeWithPath(
-            'vs/platform/actions/common/menuService',
-            'hide.label',
-            'Hide \'{0}\'',
-            title
-        )),
+        label: ( localizeWithPath(_moduleId, 0, 'Hide \'{0}\'', title)),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({
@@ -374,4 +383,15 @@ function createMenuHide(menu, command, states) {
         get isHidden() { return !toggle.checked; },
     };
 }
-export { MenuService };
+function createConfigureKeybindingAction(commandId, when = undefined, commandService, keybindingService) {
+    return toAction({
+        id: `configureKeybinding/${commandId}`,
+        label: ( localizeWithPath(_moduleId, 1, "Configure Keybinding")),
+        run() {
+            const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);
+            const whenValue = !hasKeybinding && when ? when.serialize() : undefined;
+            commandService.executeCommand('workbench.action.openGlobalKeybindings', `@command:${commandId}` + (whenValue ? ` +when:${whenValue}` : ''));
+        }
+    });
+}
+export { MenuService, createConfigureKeybindingAction };

package/vscode/src/vs/platform/commands/common/commands.js

@@ -12,11 +12,11 @@ const CommandsRegistry = new (class {
     }
     registerCommand(idOrCommand, handler) {
         if (!idOrCommand) {
-            throw new Error(`invalid command`);
+            throw ( new Error(`invalid command`));
         }
         if (typeof idOrCommand === 'string') {
             if (!handler) {
-                throw new Error(`invalid command`);
+                throw ( new Error(`invalid command`));
             }
             return this.registerCommand({ id: idOrCommand, handler });
         }

package/vscode/src/vs/platform/configuration/common/configuration.js

@@ -51,6 +51,10 @@ function addToValueTree(settingsTreeRoot, key, value, conflictReporter) {
                 obj = curr[s] = Object.create(null);
                 break;
             case 'object':
+                if (obj === null) {
+                    conflictReporter(`Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is null`);
+                    return;
+                }
                 break;
             default:
                 conflictReporter(`Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is ${JSON.stringify(obj)}`);

package/vscode/src/vs/platform/configuration/common/configurationModels.js

@@ -13,11 +13,15 @@ function freeze(data) {
     return Object.isFrozen(data) ? data : deepFreeze(data);
 }
 class ConfigurationModel {
-    constructor(_contents = {}, _keys = [], _overrides = [], raw) {
+    static createEmptyModel(logService) {
+        return ( new ConfigurationModel({}, [], [], undefined, logService));
+    }
+    constructor(_contents, _keys, _overrides, raw, logService) {
         this._contents = _contents;
         this._keys = _keys;
         this._overrides = _overrides;
         this.raw = raw;
+        this.logService = logService;
         this.overrideConfigurations = ( new Map());
     }
     get rawConfiguration() {
@@ -27,7 +31,7 @@ class ConfigurationModel {
                     if (raw instanceof ConfigurationModel) {
                         return raw;
                     }
-                    const parser = ( new ConfigurationModelParser(''));
+                    const parser = ( new ConfigurationModelParser('', this.logService));
                     parser.parseRaw(raw);
                     return parser.configurationModel;
                 }));
@@ -69,7 +73,7 @@ class ConfigurationModel {
             get overrides() {
                 const overrides = [];
                 for (const { contents, identifiers, keys } of that.rawConfiguration.overrides) {
-                    const value = ( new ConfigurationModel(contents, keys)).getValue(section);
+                    const value = ( new ConfigurationModel(contents, keys, [], undefined, that.logService)).getValue(section);
                     if (value !== undefined) {
                         overrides.push({ identifiers, value });
                     }
@@ -140,7 +144,8 @@ class ConfigurationModel {
             contents,
             keys,
             overrides,
-            raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws
+            raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws,
+            this.logService
         ));
     }
     createOverrideConfigurationModel(identifier) {
@@ -163,7 +168,7 @@ class ConfigurationModel {
             }
             contents[key] = contentsForKey;
         }
-        return ( new ConfigurationModel(contents, this.keys, this.overrides));
+        return ( new ConfigurationModel(contents, this.keys, this.overrides, undefined, this.logService));
     }
     mergeContents(source, target) {
         for (const key of ( Object.keys(target))) {
@@ -225,7 +230,7 @@ class ConfigurationModel {
         }
     }
     updateValue(key, value, add) {
-        addToValueTree(this.contents, key, value, e => console.error(e));
+        addToValueTree(this.contents, key, value, e => this.logService.error(e));
         add = add || this.keys.indexOf(key) === -1;
         if (add) {
             this.keys.push(key);
@@ -234,21 +239,22 @@ class ConfigurationModel {
             this.overrides.push({
                 identifiers: overrideIdentifiersFromKey(key),
                 keys: ( Object.keys(this.contents[key])),
-                contents: toValuesTree(this.contents[key], message => console.error(message)),
+                contents: toValuesTree(this.contents[key], message => this.logService.error(message)),
             });
         }
     }
 }
 class ConfigurationModelParser {
-    constructor(_name) {
+    constructor(_name, logService) {
         this._name = _name;
+        this.logService = logService;
         this._raw = null;
         this._configurationModel = null;
         this._restrictedConfigurations = [];
         this._parseErrors = [];
     }
     get configurationModel() {
-        return this._configurationModel || ( new ConfigurationModel());
+        return this._configurationModel || ConfigurationModel.createEmptyModel(this.logService);
     }
     get restrictedConfigurations() {
         return this._restrictedConfigurations;
@@ -274,7 +280,8 @@ class ConfigurationModelParser {
             contents,
             keys,
             overrides,
-            hasExcludedProperties ? [raw] : undefined
+            hasExcludedProperties ? [raw] : undefined ,
+            this.logService
         ));
         this._restrictedConfigurations = restricted || [];
     }
@@ -325,7 +332,7 @@ class ConfigurationModelParser {
                 raw = currentParent[0] || {};
             }
             catch (e) {
-                console.error(`Error while parsing settings file ${this._name}: ${e}`);
+                this.logService.error(`Error while parsing settings file ${this._name}: ${e}`);
                 this._parseErrors = [e];
             }
         }
@@ -335,9 +342,9 @@ class ConfigurationModelParser {
         const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
         const filtered = this.filter(raw, configurationProperties, true, options);
         raw = filtered.raw;
-        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const contents = toValuesTree(raw, message => this.logService.error(`Conflict in settings file ${this._name}: ${message}`));
         const keys = ( Object.keys(raw));
-        const overrides = this.toOverrides(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const overrides = this.toOverrides(raw, message => this.logService.error(`Conflict in settings file ${this._name}: ${message}`));
         return { contents, keys, overrides, restricted: filtered.restricted, hasExcludedProperties: filtered.hasExcludedProperties };
     }
     filter(properties, configurationProperties, filterOverriddenProperties, options) {
@@ -392,14 +399,15 @@ class ConfigurationModelParser {
     }
 }
 class UserSettings extends Disposable {
-    constructor(userSettingsResource, parseOptions, extUri, fileService) {
+    constructor(userSettingsResource, parseOptions, extUri, fileService, logService) {
         super();
         this.userSettingsResource = userSettingsResource;
         this.parseOptions = parseOptions;
         this.fileService = fileService;
+        this.logService = logService;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this.parser = ( new ConfigurationModelParser(( this.userSettingsResource.toString())));
+        this.parser = ( new ConfigurationModelParser(( this.userSettingsResource.toString()), logService));
         this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
         this._register(this.fileService.watch(this.userSettingsResource));
         this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)), Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(0 ) || e.isOperation(3 ) || e.isOperation(1 ) || e.isOperation(4 )) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
@@ -411,7 +419,7 @@ class UserSettings extends Disposable {
             return this.parser.configurationModel;
         }
         catch (e) {
-            return ( new ConfigurationModel());
+            return ConfigurationModel.createEmptyModel(this.logService);
         }
     }
     reparse(parseOptions) {
@@ -557,7 +565,7 @@ class ConfigurationInspectValue {
     }
 }
 let Configuration$1 = class Configuration {
-    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration = ( new ConfigurationModel()), _workspaceConfiguration = ( new ConfigurationModel()), _folderConfigurations = ( new ResourceMap()), _memoryConfiguration = ( new ConfigurationModel()), _memoryConfigurationByResource = ( new ResourceMap())) {
+    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration, _workspaceConfiguration, _folderConfigurations, _memoryConfiguration, _memoryConfigurationByResource, logService) {
         this._defaultConfiguration = _defaultConfiguration;
         this._policyConfiguration = _policyConfiguration;
         this._applicationConfiguration = _applicationConfiguration;
@@ -567,6 +575,7 @@ let Configuration$1 = class Configuration {
         this._folderConfigurations = _folderConfigurations;
         this._memoryConfiguration = _memoryConfiguration;
         this._memoryConfigurationByResource = _memoryConfigurationByResource;
+        this.logService = logService;
         this._workspaceConsolidatedConfiguration = null;
         this._foldersConsolidatedConfigurations = ( new ResourceMap());
         this._userConfiguration = null;
@@ -580,7 +589,7 @@ let Configuration$1 = class Configuration {
         if (overrides.resource) {
             memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
             if (!memoryConfiguration) {
-                memoryConfiguration = ( new ConfigurationModel());
+                memoryConfiguration = ConfigurationModel.createEmptyModel(this.logService);
                 this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
             }
         }
@@ -745,7 +754,7 @@ let Configuration$1 = class Configuration {
     compareAndDeleteFolderConfiguration(folder) {
         const folderConfig = this.folderConfigurations.get(folder);
         if (!folderConfig) {
-            throw new Error('Unknown folder');
+            throw ( new Error('Unknown folder'));
         }
         this.deleteFolderConfiguration(folder);
         const { added, updated, removed, overrides } = compare(folderConfig, undefined);
@@ -887,14 +896,14 @@ let Configuration$1 = class Configuration {
         this._folderConfigurations.forEach(folderConfiguration => folderConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key)));
         return [...( keys.values())];
     }
-    static parse(data) {
-        const defaultConfiguration = this.parseConfigurationModel(data.defaults);
-        const policyConfiguration = this.parseConfigurationModel(data.policy);
-        const applicationConfiguration = this.parseConfigurationModel(data.application);
-        const userConfiguration = this.parseConfigurationModel(data.user);
-        const workspaceConfiguration = this.parseConfigurationModel(data.workspace);
+    static parse(data, logService) {
+        const defaultConfiguration = this.parseConfigurationModel(data.defaults, logService);
+        const policyConfiguration = this.parseConfigurationModel(data.policy, logService);
+        const applicationConfiguration = this.parseConfigurationModel(data.application, logService);
+        const userConfiguration = this.parseConfigurationModel(data.user, logService);
+        const workspaceConfiguration = this.parseConfigurationModel(data.workspace, logService);
         const folders = data.folders.reduce((result, value) => {
-            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1]));
+            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1], logService));
             return result;
         }, ( new ResourceMap()));
         return ( new Configuration(
@@ -902,15 +911,16 @@ let Configuration$1 = class Configuration {
             policyConfiguration,
             applicationConfiguration,
             userConfiguration,
-            ( new ConfigurationModel()),
+            ConfigurationModel.createEmptyModel(logService),
             workspaceConfiguration,
             folders,
-            ( new ConfigurationModel()),
-            ( new ResourceMap())
+            ConfigurationModel.createEmptyModel(logService),
+            ( new ResourceMap()),
+            logService
         ));
     }
-    static parseConfigurationModel(model) {
-        return ( new ConfigurationModel(model.contents, model.keys, model.overrides));
+    static parseConfigurationModel(model, logService) {
+        return ( new ConfigurationModel(model.contents, model.keys, model.overrides, undefined, logService));
     }
 };
 function mergeChanges(...changes) {
@@ -934,11 +944,12 @@ function mergeChanges(...changes) {
     return { keys: [...( keysSet.values())], overrides };
 }
 class ConfigurationChangeEvent {
-    constructor(change, previous, currentConfiguraiton, currentWorkspace) {
+    constructor(change, previous, currentConfiguraiton, currentWorkspace, logService) {
         this.change = change;
         this.previous = previous;
         this.currentConfiguraiton = currentConfiguraiton;
         this.currentWorkspace = currentWorkspace;
+        this.logService = logService;
         this._marker = '\n';
         this._markerCode1 = this._marker.charCodeAt(0);
         this._markerCode2 = '.'.charCodeAt(0);
@@ -959,7 +970,7 @@ class ConfigurationChangeEvent {
     }
     get previousConfiguration() {
         if (!this._previousConfiguration && this.previous) {
-            this._previousConfiguration = Configuration$1.parse(this.previous.data);
+            this._previousConfiguration = Configuration$1.parse(this.previous.data, this.logService);
         }
         return this._previousConfiguration;
     }