@codingame/monaco-vscode-api 1.83.4 → 1.83.6

package/monaco.js

@@ -53,6 +53,7 @@ import './vscode/src/vs/workbench/contrib/folding/browser/folding.contribution.j
 import './vscode/src/vs/workbench/contrib/inlayHints/browser/inlayHintsAccessibilty.js';
 import './vscode/src/vs/workbench/contrib/codeActions/browser/codeActions.contribution.js';
 import './vscode/src/vs/workbench/contrib/list/browser/list.contribution.js';
+import './vscode/src/vs/workbench/contrib/codeEditor/browser/editorFeatures.js';
 let ExtensionPoints = class ExtensionPoints {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.4",
+  "version": "1.83.6",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {

package/service-override/extensions.js

@@ -47,10 +47,10 @@ import getServiceOverride$1 from './output.js';
 import { changeUrlDomain } from './tools/url.js';
 import { registerAssets } from '../assets.js';
 import { unsupported } from '../tools.js';
-import '../vscode/src/vs/workbench/api/common/jsonValidationExtensionPoint.js';
 import '../vscode/src/vs/workbench/services/themes/common/colorExtensionPoint.js';
 import '../vscode/src/vs/workbench/services/themes/common/iconExtensionPoint.js';
-import '../vscode/src/vs/workbench/services/themes/common/tokenClassificationExtensionPoint.js';
+import '../vscode/src/vs/workbench/services/extensions/common/extensionsRegistry.js';
+import '../vscode/src/vs/platform/theme/common/tokenClassificationRegistry.js';
 import '../vscode/src/vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint.js';
 import '../vscode/src/vs/workbench/api/browser/statusBarExtensionPoint.js';
 import '../vscode/src/vs/workbench/api/browser/mainThreadLocalization.js';
@@ -396,14 +396,14 @@ let SimpleExtensionService = class SimpleExtensionService extends AbstractExtens
     }
     async deltaExtensions(toAdd, toRemove) {
         const extHostPicker = this._extensionHostKindPicker;
+        for (const extension of toRemove) {
+            extHostPicker.removeForcedExtensionHostKind(extension.identifier.id);
+        }
         for (const extension of toAdd) {
             if (extension.extHostKind != null) {
                 extHostPicker.setForcedExtensionHostKind(extension.identifier.id, extension.extHostKind);
             }
         }
-        for (const extension of toRemove) {
-            extHostPicker.removeForcedExtensionHostKind(extension.identifier.id);
-        }
         await this._handleDeltaExtensions(new DeltaExtensionsQueueItem(toAdd, toRemove));
     }
     async _resolveExtensions() {

package/service-override/files.js

@@ -16,6 +16,8 @@ export { HTMLFileSystemProvider } from 'monaco-editor/esm/vs/platform/files/brow
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import '../vscode/src/vs/workbench/contrib/files/browser/files.contribution.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+export { IndexedDBFileSystemProvider } from '../vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
+export { IndexedDB } from 'monaco-editor/esm/vs/base/browser/indexedDB.js';
 class RegisteredFile {
     constructor(uri, readonly) {
         this.uri = uri;
@@ -389,21 +391,27 @@ class DelegateFileSystemProvider {
 const fileSystemProvider = new OverlayFileSystemProvider();
 fileSystemProvider.register(0, new MkdirpOnWriteInMemoryFileSystemProvider());
 const extensionFileSystemProvider = new RegisteredFileSystemProvider(true);
+const userDataFileSystemProvider = new InMemoryFileSystemProvider();
+void userDataFileSystemProvider.mkdir(( URI.from({ scheme: Schemas.vscodeUserData, path: '/User/' })));
+const providers = {
+    extension: extensionFileSystemProvider,
+    logs: new InMemoryFileSystemProvider(),
+    [Schemas.vscodeUserData]: userDataFileSystemProvider,
+    [Schemas.tmp]: new InMemoryFileSystemProvider(),
+    file: fileSystemProvider
+};
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
-        const userMemoryFileSystem = new InMemoryFileSystemProvider();
-        this.registerProvider('user', userMemoryFileSystem);
-        this.registerProvider('extension', extensionFileSystemProvider);
-        this.registerProvider('cache', new InMemoryFileSystemProvider());
-        this.registerProvider('logs', new InMemoryFileSystemProvider());
-        this.registerProvider(Schemas.vscodeUserData, new InMemoryFileSystemProvider());
-        this.registerProvider(Schemas.tmp, new InMemoryFileSystemProvider());
-        let fileSystemProviderDisposable = this.registerProvider('file', fileSystemProvider);
-        fileSystemProvider.onDidChangeOverlays(() => {
-            fileSystemProviderDisposable.dispose();
-            fileSystemProviderDisposable = this.registerProvider('file', fileSystemProvider);
-        });
+        for (const [scheme, provider] of Object.entries(providers)) {
+            let disposable = this.registerProvider(scheme, provider);
+            if (provider instanceof OverlayFileSystemProvider) {
+                provider.onDidChangeOverlays(() => {
+                    disposable.dispose();
+                    disposable = this.registerProvider(scheme, fileSystemProvider);
+                });
+            }
+        }
     }
 };
 MemoryFileService = __decorate([
@@ -414,10 +422,26 @@ function getServiceOverride() {
         [( IFileService.toString())]: new SyncDescriptor(MemoryFileService, [], true)
     };
 }
+function registerCustomProvider(scheme, provider) {
+    providers[scheme] = provider;
+}
 function registerExtensionFile(extensionLocation, filePath, getContent) {
     return extensionFileSystemProvider.registerFile(new RegisteredReadOnlyFile(joinPath(extensionLocation, filePath), getContent));
 }
+async function initFile(scheme, file, content, options) {
+    const provider = providers[scheme];
+    if (provider == null || provider.writeFile == null) {
+        throw new Error(`${scheme} provider doesn't exist or doesn't support writing files`);
+    }
+    await provider.writeFile(file, content instanceof Uint8Array ? content : encoder.encode(content), {
+        atomic: false,
+        create: true,
+        overwrite: false,
+        unlock: false,
+        ...options
+    });
+}
 function registerFileSystemOverlay(priority, provider) {
     return fileSystemProvider.register(priority, provider);
 }
-export { DelegateFileSystemProvider, FilePermission, FileType, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { DelegateFileSystemProvider, FilePermission, FileType, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay };

package/service-override/keybindings.js

@@ -20,12 +20,18 @@ import { IHostService } from '../vscode/src/vs/workbench/services/host/browser/h
 import { IExtensionService } from '../vscode/src/vs/workbench/services/extensions/common/extensions.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { WorkbenchContextKeysHandler } from '../vscode/src/vs/workbench/browser/contextkeys.js';
-import getServiceOverride$1 from './files.js';
-import '../vscode/src/vs/workbench/browser/workbench.contribution.js';
-import '../vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import getServiceOverride$1, { initFile } from './files.js';
 import { onRenderWorkbench } from '../lifecycle.js';
 import '../services.js';
+import '../vscode/src/vs/workbench/browser/workbench.contribution.js';
+import '../vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const defaultUserKeybindindsFile = ( URI.from({ scheme: Schemas.vscodeUserData, path: '/User/keybindings.json' }));
+async function initUserKeybindings(configurationJson, options, file = defaultUserKeybindindsFile) {
+    await initFile(defaultUserKeybindindsFile.scheme, file, configurationJson, options);
+}
 async function updateUserKeybindings(keybindingsJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
@@ -84,4 +90,4 @@ function getServiceOverride({ shouldUseGlobalKeybindings = () => false } = {}) {
         [( ICommandService.toString())]: new SyncDescriptor(CommandService, [], true)
     };
 }
-export { getServiceOverride as default, updateUserKeybindings };
+export { getServiceOverride as default, defaultUserKeybindindsFile, initUserKeybindings, updateUserKeybindings };

package/service-override/layout.js

@@ -178,10 +178,8 @@ class LayoutService {
                     void this.paneCompositeService.openPaneComposite(panelToOpen, location, true);
                 }
             }
-            if (this.paneCompositeService.getPartByLocation != null) {
-                this.paneCompositeService.getPartByLocation(location).setVisible(!hidden);
-            }
         }
+        this.getPart(part).setVisible(!hidden);
     }
     isVisible(part) {
         return !( this.hiddenParts.has(part));

package/services.d.ts

@@ -5,9 +5,10 @@ export { IColorTheme, IThemeService } from './vscode/src/vs/platform/theme/commo
 export { IStorageService, StorageScope, StorageTarget } from './vscode/src/vs/platform/storage/common/storage.js';
 import { IEditorOverrideServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 export { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
-import { ServiceIdentifier } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
+import { ServiceIdentifier, GetLeadingNonServiceArgs, ServicesAccessor } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 export { IInstantiationService } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 export { IAction } from './vscode/src/vs/base/common/actions.js';
+import { IDisposable } from './vscode/src/vs/base/common/lifecycle.js';
 export { SyncDescriptor } from './vscode/src/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from './vscode/src/vs/platform/commands/common/commands.js';
 export { INeverShowAgainOptions, INotification, INotificationActions, INotificationHandle, INotificationProgress, INotificationProgressProperties, INotificationProperties, INotificationService, IPromptChoice, IPromptChoiceWithMenu, IPromptOptions, IStatusMessageOptions, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationMessage, NotificationPriority, NotificationsFilter } from './vscode/src/vs/platform/notification/common/notification.js';
@@ -61,6 +62,8 @@ export { IRemoteAgentService } from './vscode/src/vs/workbench/services/remote/c
 export { IRemoteAuthorityResolverService } from './vscode/src/vs/platform/remote/common/remoteAuthorityResolver.js';
 export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js';
 export { ITerminalInstanceService, ITerminalService } from './vscode/src/vs/workbench/contrib/terminal/browser/terminal.js';
+export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
+export { ILabelService } from './vscode/src/vs/platform/label/common/label.js';
 export { IMarkdownString, MarkdownStringTrustedOptions } from './vscode/src/vs/base/common/htmlContent.js';
 export { IActivityService, IBadge } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/workbench/services/hover/browser/hover.js';
@@ -71,6 +74,14 @@ export { IBannerService } from './vscode/src/vs/workbench/services/banner/browse
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService, IWorkspaceTrustUriInfo } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 
 declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement): Promise<void>;
+declare function waitServicesReady(): Promise<void>;
+declare function checkServicesReady(): void;
 declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;
+declare function createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): Promise<R>;
+declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
+/**
+ * Equivalent to `StandaloneServices.withServices` except the callback is called when the services are ready, not just initialized
+ */
+declare function withReadyServices(callback: (serviceAccessor: ServicesAccessor) => IDisposable): IDisposable;
 
-export { getService, initialize };
+export { checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };

package/services.js

@@ -3,13 +3,15 @@ export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.j
 export { StorageScope, StorageTarget } from './vscode/src/vs/platform/storage/common/storage.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+export { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import getServiceOverride from './service-override/layout.js';
 import getServiceOverride$1 from './service-override/environment.js';
 import getServiceOverride$2 from './service-override/extensions.js';
 import getServiceOverride$3 from './service-override/files.js';
 import getServiceOverride$4 from './service-override/quickaccess.js';
-import { startup, serviceInitializedBarrier } from './lifecycle.js';
+import { startup, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
 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';
@@ -24,7 +26,6 @@ export { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/r
 export { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 import './override/vs/platform/dialogs/common/dialogs.js';
 export { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-export { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 export { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
 export { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 export { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
@@ -65,6 +66,8 @@ export { IRemoteAgentService } from './vscode/src/vs/workbench/services/remote/c
 export { IRemoteAuthorityResolverService } from './vscode/src/vs/platform/remote/common/remoteAuthorityResolver.js';
 export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js';
 export { ITerminalInstanceService, ITerminalService } from './vscode/src/vs/workbench/contrib/terminal/browser/terminal.js';
+export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
+export { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
 export { IActivityService } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/workbench/services/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';
@@ -92,8 +95,35 @@ async function initialize(overrides, container) {
     });
     await startup(instantiationService);
 }
-async function getService(identifier) {
+async function waitServicesReady() {
     await serviceInitializedBarrier.wait();
+}
+function checkServicesReady() {
+    if (!serviceInitializedBarrier.isOpen()) {
+        throw new Error('Services are not ready yet');
+    }
+}
+async function getService(identifier) {
+    await waitServicesReady();
     return StandaloneServices.get(identifier);
 }
-export { getService, initialize };
+async function createInstance(ctor, ...args) {
+    await waitServicesReady();
+    return StandaloneServices.get(IInstantiationService).createInstance(ctor, ...args);
+}
+function createInstanceSync(ctor, ...args) {
+    checkServicesReady();
+    return StandaloneServices.get(IInstantiationService).createInstance(ctor, ...args);
+}
+function withReadyServices(callback) {
+    if (serviceInitializedBarrier.isOpen()) {
+        return StandaloneServices.get(IInstantiationService).invokeFunction(callback);
+    }
+    const disposable = new DisposableStore();
+    const listener = disposable.add(serviceInitializedEmitter.event(() => {
+        listener.dispose();
+        disposable.add(StandaloneServices.get(IInstantiationService).invokeFunction(callback));
+    }));
+    return disposable;
+}
+export { checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };

package/vscode/src/vs/base/browser/broadcast.js

@@ -0,0 +1,52 @@
+import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class BroadcastDataChannel extends Disposable {
+    constructor(channelName) {
+        super();
+        this.channelName = channelName;
+        this._onDidReceiveData = this._register(( new Emitter()));
+        this.onDidReceiveData = this._onDidReceiveData.event;
+        if ('BroadcastChannel' in window) {
+            try {
+                this.broadcastChannel = ( new BroadcastChannel(channelName));
+                const listener = (event) => {
+                    this._onDidReceiveData.fire(event.data);
+                };
+                this.broadcastChannel.addEventListener('message', listener);
+                this._register(toDisposable(() => {
+                    if (this.broadcastChannel) {
+                        this.broadcastChannel.removeEventListener('message', listener);
+                        this.broadcastChannel.close();
+                    }
+                }));
+            }
+            catch (error) {
+                console.warn('Error while creating broadcast channel. Falling back to localStorage.', getErrorMessage(error));
+            }
+        }
+        if (!this.broadcastChannel) {
+            this.channelName = `BroadcastDataChannel.${channelName}`;
+            this.createBroadcastChannel();
+        }
+    }
+    createBroadcastChannel() {
+        const listener = (event) => {
+            if (event.key === this.channelName && event.newValue) {
+                this._onDidReceiveData.fire(JSON.parse(event.newValue));
+            }
+        };
+        window.addEventListener('storage', listener);
+        this._register(toDisposable(() => window.removeEventListener('storage', listener)));
+    }
+    postData(data) {
+        if (this.broadcastChannel) {
+            this.broadcastChannel.postMessage(data);
+        }
+        else {
+            window.localStorage.removeItem(this.channelName);
+            window.localStorage.setItem(this.channelName, JSON.stringify(data));
+        }
+    }
+}
+export { BroadcastDataChannel };

package/vscode/src/vs/base/browser/ui/menu/menubar.js

@@ -216,7 +216,7 @@ class MenuBar extends Disposable {
         });
     }
     createOverflowMenu() {
-        const label = this.isCompact ? nls.localizeWithPath('vs/base/browser/ui/menu/menubar', 'mAppMenu', 'Application Menu') : nls.localizeWithPath('vs/base/browser/ui/menu/menubar', 'mMore', 'More');
+        const label = this.isCompact ? ( nls.localizeWithPath('vs/base/browser/ui/menu/menubar', 'mAppMenu', 'Application Menu')) : ( nls.localizeWithPath('vs/base/browser/ui/menu/menubar', 'mMore', 'More'));
         const buttonElement = $('div.menubar-menu-button', { 'role': 'menuitem', 'tabindex': this.isCompact ? 0 : -1, 'aria-label': label, 'aria-haspopup': true });
         const titleElement = $('div.menubar-menu-title.toolbar-toggle-more' + ThemeIcon.asCSSSelector(Codicon.menuBarMore), { 'role': 'none', 'aria-hidden': true });
         buttonElement.appendChild(titleElement);

package/vscode/src/vs/base/browser/ui/splitview/paneview.js

@@ -77,7 +77,12 @@ class Pane extends Disposable {
         this.orthogonalSize = 0;
         this._expanded = typeof options.expanded === 'undefined' ? true : !!options.expanded;
         this._orientation = typeof options.orientation === 'undefined' ? 0  : options.orientation;
-        this._ariaHeaderLabel = localizeWithPath('vs/base/browser/ui/splitview/paneview', 'viewSection', "{0} Section", options.title);
+        this._ariaHeaderLabel = ( localizeWithPath(
+            'vs/base/browser/ui/splitview/paneview',
+            'viewSection',
+            "{0} Section",
+            options.title
+        ));
         this._minimumBodySize = typeof options.minimumBodySize === 'number' ? options.minimumBodySize : this._orientation === 1  ? 200 : 120;
         this._maximumBodySize = typeof options.maximumBodySize === 'number' ? options.maximumBodySize : Number.POSITIVE_INFINITY;
         this.element = $('.pane');