@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.85.0",
+  "version": "1.85.2",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -16,7 +16,6 @@
   "private": false,
   "main": "api.js",
   "module": "api.js",
-  "types": "vscode.proposed.d.ts",
   "exports": {
     ".": {
       "default": "./api.js"
@@ -100,10 +99,12 @@
   "dependencies": {
     "monaco-editor": "0.45.0",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-layout-service-override": "1.85.0",
-    "@codingame/monaco-vscode-environment-service-override": "1.85.0",
-    "@codingame/monaco-vscode-extensions-service-override": "1.85.0",
-    "@codingame/monaco-vscode-files-service-override": "1.85.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "1.85.0"
+    "@codingame/monaco-vscode-files-service-override": "1.85.2",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.85.2",
+    "@codingame/monaco-vscode-extensions-service-override": "1.85.2",
+    "@codingame/monaco-vscode-environment-service-override": "1.85.2",
+    "@codingame/monaco-vscode-layout-service-override": "1.85.2",
+    "@codingame/monaco-vscode-host-service-override": "1.85.2",
+    "@codingame/monaco-vscode-base-service-override": "1.85.2"
   }
 }

package/service-override/tools/editor.js

@@ -343,7 +343,7 @@ let MonacoDelegateEditorGroupsService = class MonacoDelegateEditorGroupsService
             return this.delegate.getLayout();
         };
         this.getGroups = (order) => {
-            return [...this.additionalGroups, ...this.delegate.getGroups(order)];
+            return [...this.delegate.getGroups(order), ...this.additionalGroups];
         };
         this.getGroup = (identifier) => {
             return this.delegate.getGroup(identifier) ?? this.additionalGroups.find(group => group.id === identifier);

package/services.js

@@ -10,13 +10,15 @@ export { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiati
 import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
 export { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import getServiceOverride$1 from '@codingame/monaco-vscode-layout-service-override';
-import getServiceOverride$1$1 from '@codingame/monaco-vscode-environment-service-override';
-import getServiceOverride$2 from '@codingame/monaco-vscode-extensions-service-override';
-import getServiceOverride$1$2 from '@codingame/monaco-vscode-files-service-override';
-import getServiceOverride$4 from '@codingame/monaco-vscode-quickaccess-service-override';
-import { checkServicesNotInitialized, startup, waitServicesReady, checkServicesReady, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
 import { initialize as initialize$1 } from './workbench.js';
+import { checkServicesNotInitialized, startup, waitServicesReady, checkServicesReady, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
+import getServiceOverride$4 from '@codingame/monaco-vscode-quickaccess-service-override';
+import getServiceOverride$1$2 from '@codingame/monaco-vscode-files-service-override';
+import getServiceOverride$2 from '@codingame/monaco-vscode-extensions-service-override';
+import getServiceOverride$1$1 from '@codingame/monaco-vscode-environment-service-override';
+import getServiceOverride$1 from '@codingame/monaco-vscode-layout-service-override';
+import getServiceOverride$5 from '@codingame/monaco-vscode-host-service-override';
+import getServiceOverride$6 from '@codingame/monaco-vscode-base-service-override';
 export { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 export { INotificationService, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationPriority, NotificationsFilter } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -103,6 +105,8 @@ async function initialize(overrides, container = document.body, configuration =
         ...getServiceOverride$2(),
         ...getServiceOverride$1$2(),
         ...getServiceOverride$4(),
+        ...getServiceOverride$5(),
+        ...getServiceOverride$6(),
         ...overrides
     });
     await startup(instantiationService);

package/vscode/src/vs/base/browser/ui/tree/treeDefaults.js

@@ -0,0 +1,14 @@
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+class CollapseAllAction extends Action {
+    constructor(viewer, enabled) {
+        super('vs.tree.collapse', ( nls.localizeWithPath('vs/base/browser/ui/tree/treeDefaults', 'collapse all', "Collapse All")), 'collapse-all', enabled);
+        this.viewer = viewer;
+    }
+    async run() {
+        this.viewer.collapseAll();
+        this.viewer.setSelection([]);
+        this.viewer.setFocus([]);
+    }
+}
+export { CollapseAllAction };

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

@@ -140,6 +140,13 @@ function format(documentText, range, options) {
     }
     return editOperations;
 }
+function toFormattedString(obj, options) {
+    const content = JSON.stringify(obj, undefined, options.insertSpaces ? options.tabSize || 4 : '\t');
+    if (options.eol !== undefined) {
+        return content.replace(/\r\n|\r|\n/g, options.eol);
+    }
+    return content;
+}
 function repeat(s, count) {
     let result = '';
     for (let i = 0; i < count; i++) {
@@ -184,4 +191,4 @@ function getEOL(options, text) {
 function isEOL(text, offset) {
     return '\r\n'.indexOf(text.charAt(offset)) !== -1;
 }
-export { format, getEOL, isEOL };
+export { format, getEOL, isEOL, toFormattedString };

package/vscode/src/vs/platform/actions/browser/buttonbar.js

@@ -0,0 +1,128 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ButtonBar } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { ActionRunner, SubmenuAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
+    constructor(container, _options, _contextMenuService, _keybindingService, telemetryService) {
+        super(container);
+        this._options = _options;
+        this._contextMenuService = _contextMenuService;
+        this._keybindingService = _keybindingService;
+        this._store = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._actionRunner = this._store.add(( new ActionRunner()));
+        if (_options?.telemetrySource) {
+            this._actionRunner.onDidRun(e => {
+                telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: _options.telemetrySource });
+            }, undefined, this._store);
+        }
+    }
+    dispose() {
+        this._onDidChange.dispose();
+        this._store.dispose();
+        super.dispose();
+    }
+    update(actions) {
+        const conifgProvider = this._options?.buttonConfigProvider ?? (() => ({ showLabel: true }));
+        this.clear();
+        for (let i = 0; i < actions.length; i++) {
+            const secondary = i > 0;
+            const actionOrSubmenu = actions[i];
+            let action;
+            let btn;
+            if (actionOrSubmenu instanceof SubmenuAction && actionOrSubmenu.actions.length > 0) {
+                const [first, ...rest] = actionOrSubmenu.actions;
+                action = first;
+                btn = this.addButtonWithDropdown({
+                    secondary: conifgProvider(action)?.isSecondary ?? secondary,
+                    actionRunner: this._actionRunner,
+                    actions: rest,
+                    contextMenuProvider: this._contextMenuService,
+                });
+            }
+            else {
+                action = actionOrSubmenu;
+                btn = this.addButton({
+                    secondary: conifgProvider(action)?.isSecondary ?? secondary,
+                });
+            }
+            btn.enabled = action.enabled;
+            btn.element.classList.add('default-colors');
+            if (conifgProvider(action)?.showLabel ?? true) {
+                btn.label = action.label;
+            }
+            else {
+                btn.element.classList.add('monaco-text-button');
+            }
+            if (conifgProvider(action)?.showIcon) {
+                if (action instanceof MenuItemAction && ThemeIcon.isThemeIcon(action.item.icon)) {
+                    btn.icon = action.item.icon;
+                }
+                else if (action.class) {
+                    btn.element.classList.add(...action.class.split(' '));
+                }
+            }
+            const kb = this._keybindingService.lookupKeybinding(action.id);
+            if (kb) {
+                btn.element.title = ( localizeWithPath(
+                    'vs/platform/actions/browser/buttonbar',
+                    'labelWithKeybinding',
+                    "{0} ({1})",
+                    action.label,
+                    kb.getLabel()
+                ));
+            }
+            else {
+                btn.element.title = action.label;
+            }
+            btn.onDidClick(async () => {
+                this._actionRunner.run(action);
+            });
+        }
+        this._onDidChange.fire(this);
+    }
+};
+WorkbenchButtonBar = ( __decorate([
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, ITelemetryService))
+], WorkbenchButtonBar));
+let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButtonBar {
+    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
+        super(container, options, contextMenuService, keybindingService, telemetryService);
+        const menu = menuService.createMenu(menuId, contextKeyService);
+        this._store.add(menu);
+        const update = () => {
+            this.clear();
+            const actions = menu
+                .getActions({ renderShortTitle: true })
+                .flatMap(entry => entry[1]);
+            super.update(actions);
+        };
+        this._store.add(menu.onDidChange(update));
+        update();
+    }
+    dispose() {
+        super.dispose();
+    }
+    update(_actions) {
+        throw new Error('Use Menu or WorkbenchButtonBar');
+    }
+};
+MenuWorkbenchButtonBar = ( __decorate([
+    ( __param(3, IMenuService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, ITelemetryService))
+], MenuWorkbenchButtonBar));
+export { MenuWorkbenchButtonBar, WorkbenchButtonBar };

package/vscode/src/vs/platform/extensionManagement/common/extensionEnablementService.js

@@ -0,0 +1,140 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { DISABLED_EXTENSIONS_STORAGE_PATH, IExtensionManagementService } from './extensionManagement.js';
+import { areSameExtensions } from './extensionManagementUtil.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+let GlobalExtensionEnablementService = class GlobalExtensionEnablementService extends Disposable {
+    constructor(storageService, extensionManagementService) {
+        super();
+        this._onDidChangeEnablement = ( new Emitter());
+        this.onDidChangeEnablement = this._onDidChangeEnablement.event;
+        this.storageManger = this._register(( new StorageManager(storageService)));
+        this._register(this.storageManger.onDidChange(extensions => this._onDidChangeEnablement.fire({ extensions, source: 'storage' })));
+        this._register(extensionManagementService.onDidInstallExtensions(e => e.forEach(({ local, operation }) => {
+            if (local && operation === 4 ) {
+                this._removeFromDisabledExtensions(local.identifier);
+            }
+        })));
+    }
+    async enableExtension(extension, source) {
+        if (this._removeFromDisabledExtensions(extension)) {
+            this._onDidChangeEnablement.fire({ extensions: [extension], source });
+            return true;
+        }
+        return false;
+    }
+    async disableExtension(extension, source) {
+        if (this._addToDisabledExtensions(extension)) {
+            this._onDidChangeEnablement.fire({ extensions: [extension], source });
+            return true;
+        }
+        return false;
+    }
+    getDisabledExtensions() {
+        return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
+    }
+    async getDisabledExtensionsAsync() {
+        return this.getDisabledExtensions();
+    }
+    _addToDisabledExtensions(identifier) {
+        const disabledExtensions = this.getDisabledExtensions();
+        if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
+            disabledExtensions.push(identifier);
+            this._setDisabledExtensions(disabledExtensions);
+            return true;
+        }
+        return false;
+    }
+    _removeFromDisabledExtensions(identifier) {
+        const disabledExtensions = this.getDisabledExtensions();
+        for (let index = 0; index < disabledExtensions.length; index++) {
+            const disabledExtension = disabledExtensions[index];
+            if (areSameExtensions(disabledExtension, identifier)) {
+                disabledExtensions.splice(index, 1);
+                this._setDisabledExtensions(disabledExtensions);
+                return true;
+            }
+        }
+        return false;
+    }
+    _setDisabledExtensions(disabledExtensions) {
+        this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
+    }
+    _getExtensions(storageId) {
+        return this.storageManger.get(storageId, 0 );
+    }
+    _setExtensions(storageId, extensions) {
+        this.storageManger.set(storageId, extensions, 0 );
+    }
+};
+GlobalExtensionEnablementService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionManagementService))
+], GlobalExtensionEnablementService));
+class StorageManager extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.storage = Object.create(null);
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(storageService.onDidChangeValue(0 , undefined, this._register(( new DisposableStore())))(e => this.onDidStorageChange(e)));
+    }
+    get(key, scope) {
+        let value;
+        if (scope === 0 ) {
+            if (isUndefinedOrNull(this.storage[key])) {
+                this.storage[key] = this._get(key, scope);
+            }
+            value = this.storage[key];
+        }
+        else {
+            value = this._get(key, scope);
+        }
+        return JSON.parse(value);
+    }
+    set(key, value, scope) {
+        const newValue = JSON.stringify(( value.map(({ id, uuid }) => ({ id, uuid }))));
+        const oldValue = this._get(key, scope);
+        if (oldValue !== newValue) {
+            if (scope === 0 ) {
+                if (value.length) {
+                    this.storage[key] = newValue;
+                }
+                else {
+                    delete this.storage[key];
+                }
+            }
+            this._set(key, value.length ? newValue : undefined, scope);
+        }
+    }
+    onDidStorageChange(storageChangeEvent) {
+        if (!isUndefinedOrNull(this.storage[storageChangeEvent.key])) {
+            const newValue = this._get(storageChangeEvent.key, storageChangeEvent.scope);
+            if (newValue !== this.storage[storageChangeEvent.key]) {
+                const oldValues = this.get(storageChangeEvent.key, storageChangeEvent.scope);
+                delete this.storage[storageChangeEvent.key];
+                const newValues = this.get(storageChangeEvent.key, storageChangeEvent.scope);
+                const added = oldValues.filter(oldValue => !( newValues.some(newValue => areSameExtensions(oldValue, newValue))));
+                const removed = newValues.filter(newValue => !( oldValues.some(oldValue => areSameExtensions(oldValue, newValue))));
+                if (added.length || removed.length) {
+                    this._onDidChange.fire([...added, ...removed]);
+                }
+            }
+        }
+    }
+    _get(key, scope) {
+        return this.storageService.get(key, scope, '[]');
+    }
+    _set(key, value, scope) {
+        if (value) {
+            this.storageService.store(key, value, scope, 1 );
+        }
+        else {
+            this.storageService.remove(key, scope);
+        }
+    }
+}
+export { GlobalExtensionEnablementService, StorageManager };

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

@@ -3,6 +3,7 @@ import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/com
 const EXTENSION_IDENTIFIER_PATTERN = '^([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$';
 const EXTENSION_IDENTIFIER_REGEX = ( new RegExp(EXTENSION_IDENTIFIER_PATTERN));
 const WEB_EXTENSION_TAG = '__web_extension';
+const EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT = 'skipWalkthrough';
 const EXTENSION_INSTALL_SYNC_CONTEXT = 'extensionsSync';
 const EXTENSION_INSTALL_DEP_PACK_CONTEXT = 'dependecyOrPackExtensionInstall';
 function TargetPlatformToString(targetPlatform) {
@@ -141,4 +142,4 @@ const PreferencesLocalizedLabel = { value: ( localizeWithPath(
     'preferences',
     "Preferences"
 )), original: 'Preferences' };
-export { DISABLED_EXTENSIONS_STORAGE_PATH, ENABLED_EXTENSIONS_STORAGE_PATH, EXTENSION_IDENTIFIER_PATTERN, EXTENSION_IDENTIFIER_REGEX, EXTENSION_INSTALL_DEP_PACK_CONTEXT, EXTENSION_INSTALL_SYNC_CONTEXT, ExtensionManagementError, ExtensionManagementErrorCode, ExtensionsLabel, ExtensionsLocalizedLabel, IExtensionGalleryService, IExtensionManagementService, IExtensionTipsService, IGlobalExtensionEnablementService, PreferencesLocalizedLabel, TargetPlatformToString, WEB_EXTENSION_TAG, getTargetPlatform, isNotWebExtensionInWebTargetPlatform, isTargetPlatformCompatible, toTargetPlatform };
+export { DISABLED_EXTENSIONS_STORAGE_PATH, ENABLED_EXTENSIONS_STORAGE_PATH, EXTENSION_IDENTIFIER_PATTERN, EXTENSION_IDENTIFIER_REGEX, EXTENSION_INSTALL_DEP_PACK_CONTEXT, EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT, EXTENSION_INSTALL_SYNC_CONTEXT, ExtensionManagementError, ExtensionManagementErrorCode, ExtensionsLabel, ExtensionsLocalizedLabel, IExtensionGalleryService, IExtensionManagementService, IExtensionTipsService, IGlobalExtensionEnablementService, PreferencesLocalizedLabel, TargetPlatformToString, WEB_EXTENSION_TAG, getTargetPlatform, isNotWebExtensionInWebTargetPlatform, isTargetPlatformCompatible, toTargetPlatform };