@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/service-override/files.js

@@ -4,13 +4,14 @@ import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/comm
 import { FileService } from '../vscode/vs/platform/files/common/fileService.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { InMemoryFileSystemProvider } from '../vscode/vs/platform/files/common/inMemoryFilesystemProvider.js';
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { FileType } from '../vscode/vs/platform/files/common/files.js';
+export { FileChangeType, FileSystemProviderCapabilities } from '../vscode/vs/platform/files/common/files.js';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileSystemProviderError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 export { FileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ITextFileService } from '../vscode/vs/workbench/services/textfile/common/textfiles.js';
-import { BrowserTextFileService } from '../vscode/vs/workbench/services/textfile/browser/browserTextFileService.js';
 import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+export { HTMLFileSystemProvider } from 'monaco-editor/esm/vs/platform/files/browser/htmlFileSystemProvider.js';
 import '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
 class File {
     constructor(getContent) {
@@ -72,8 +73,9 @@ class SimpleTextFileSystemProvider {
     }
     async mkdir() {
     }
-    readdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    async readdir(directory) {
+        console.debug('Not implemented: readdir', directory);
+        return [];
     }
     delete() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
@@ -99,7 +101,13 @@ class ExtensionFileSystemProviderWithFileReadWriteCapability {
     async readFile(resource) {
         const file = this.files.get(( resource.toString()));
         if (file != null) {
-            return encoder.encode(await file.getContent());
+            const data = await file.getContent();
+            if (data instanceof Uint8Array) {
+                return data;
+            }
+            else {
+                return encoder.encode(data);
+            }
         }
         throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
     }
@@ -131,6 +139,9 @@ class ExtensionFileSystemProviderWithFileReadWriteCapability {
     }
 }
 const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
+function isFullfiled(result) {
+    return result.status === 'fulfilled';
+}
 class OverlayFileSystemProvider {
     constructor(_default) {
         this._default = _default;
@@ -138,10 +149,9 @@ class OverlayFileSystemProvider {
         this.onDidChangeCapabilities = Event.any(...( this.delegates.map(delegate => delegate.onDidChangeCapabilities)));
         this._onDidChangeFile = new Emitter();
         this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
+        this._onDidChangeOverlays = new Emitter();
+        this.onDidChangeOverlays = this._onDidChangeOverlays.event;
         this.capabilities = 2  | 1024 ;
-        _default.onDidChangeFile((e) => {
-            this._onDidChangeFile.fire(e);
-        });
     }
     register(delegate) {
         this.others.push(delegate);
@@ -154,9 +164,11 @@ class OverlayFileSystemProvider {
                 const index = this.others.indexOf(delegate);
                 if (index >= 0) {
                     this.others.splice(index, 1);
+                    this._onDidChangeOverlays.fire();
                 }
             }
         });
+        this._onDidChangeOverlays.fire();
         return disposableStore;
     }
     get delegates() {
@@ -179,11 +191,14 @@ class OverlayFileSystemProvider {
         throw firstError;
     }
     async writeToDelegates(caller) {
-        await Promise.all(( this.delegates.map(async (delegate) => {
+        const results = await Promise.allSettled(( this.delegates.map(async (delegate) => {
             if (((delegate.capabilities & 2048) ) === 0) {
                 await caller(delegate);
             }
         })));
+        if (!( results.some(result => result.status === 'fulfilled'))) {
+            throw results[0].reason;
+        }
     }
     async stat(resource) {
         return this.readFromDelegates(delegate => delegate.stat(resource));
@@ -192,7 +207,11 @@ class OverlayFileSystemProvider {
         return this.readFromDelegates(delegate => delegate.readFile(resource));
     }
     async readdir(resource) {
-        return this.readFromDelegates(delegate => delegate.readdir(resource));
+        const results = await Promise.allSettled(( this.delegates.map(delegate => delegate.readdir(resource))));
+        if (!( results.some(result => result.status === 'fulfilled'))) {
+            throw results[0].reason;
+        }
+        return Object.entries(Object.fromEntries(( results.filter(isFullfiled).map(result => result.value)).flat()));
     }
     watch(resource, opts) {
         const store = new DisposableStore();
@@ -223,7 +242,11 @@ let MemoryFileService = class MemoryFileService extends FileService {
         this.registerProvider('extension', extensionFileSystemProvider);
         this.registerProvider('cache', new InMemoryFileSystemProvider());
         this.registerProvider('logs', new InMemoryFileSystemProvider());
-        this.registerProvider('file', fileSystemProvider);
+        let fileSystemProviderDisposable = this.registerProvider('file', fileSystemProvider);
+        fileSystemProvider.onDidChangeOverlays(() => {
+            fileSystemProviderDisposable.dispose();
+            fileSystemProviderDisposable = this.registerProvider('file', fileSystemProvider);
+        });
     }
 };
 MemoryFileService = __decorate([
@@ -231,8 +254,7 @@ MemoryFileService = __decorate([
 ], MemoryFileService);
 function getServiceOverride() {
     return {
-        [( IFileService.toString())]: new SyncDescriptor(MemoryFileService),
-        [( ITextFileService.toString())]: new SyncDescriptor(BrowserTextFileService)
+        [( IFileService.toString())]: new SyncDescriptor(MemoryFileService)
     };
 }
 function registerExtensionFile(extensionLocation, path, getContent) {
@@ -241,4 +263,4 @@ function registerExtensionFile(extensionLocation, path, getContent) {
 function registerFileSystemOverlay(provider) {
     return fileSystemProvider.register(provider);
 }
-export { SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FileType, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/keybindings.d.ts

@@ -1,15 +1,13 @@
-import * as monaco from 'monaco-editor';
-
-interface IUserFriendlyKeybinding {
-    key: string;
-    command: string;
-    args?: any;
-    when?: string;
-}
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+export { I as IUserFriendlyKeybinding } from '../keybinding.js';
+import '../instantiation.js';
+import 'monaco-editor';
+import '../event.js';
+import 'vscode';
+import '../jsonSchema.js';
+import '../contextkey.js';
 
 declare function updateUserKeybindings(keybindingsJson: string): Promise<void>;
 declare function getServiceOverride(): IEditorOverrideServices;
 
-export { IUserFriendlyKeybinding, getServiceOverride as default, updateUserKeybindings };
+export { getServiceOverride as default, updateUserKeybindings };

package/dist/service-override/languages.d.ts

@@ -1,76 +1,6 @@
-import * as monaco from 'monaco-editor';
-
-declare class SyncDescriptor<T> {
-    readonly ctor: any;
-    readonly staticArguments: any[];
-    readonly supportsDelayedInstantiation: boolean;
-    constructor(ctor: new (...args: any[]) => T, staticArguments?: any[], supportsDelayedInstantiation?: boolean);
-}
-interface SyncDescriptor0<T> {
-    readonly ctor: new () => T;
-}
-
-declare class ServiceCollection {
-    private _entries;
-    constructor(...entries: [ServiceIdentifier<any>, any][]);
-    set<T>(id: ServiceIdentifier<T>, instanceOrDescriptor: T | SyncDescriptor<T>): T | SyncDescriptor<T>;
-    has(id: ServiceIdentifier<any>): boolean;
-    get<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T>;
-}
-
-type BrandedService = {
-    _serviceBrand: undefined;
-};
-interface ServicesAccessor {
-    get<T>(id: ServiceIdentifier<T>): T;
-}
-/**
- * Given a list of arguments as a tuple, attempt to extract the leading, non-service arguments
- * to their own tuple.
- */
-type GetLeadingNonServiceArgs<TArgs extends any[]> = TArgs extends [] ? [] : TArgs extends [...infer TFirst, BrandedService] ? GetLeadingNonServiceArgs<TFirst> : TArgs;
-declare const IInstantiationService: ServiceIdentifier<IInstantiationService>;
-interface IInstantiationService {
-    readonly _serviceBrand: undefined;
-    /**
-     * Synchronously creates an instance that is denoted by the descriptor
-     */
-    createInstance<T>(descriptor: SyncDescriptor0<T>): T;
-    createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
-    /**
-     * Calls a function with a service accessor.
-     */
-    invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R;
-    /**
-     * Creates a child of this service which inherits all current services
-     * and adds/overwrites the given services.
-     */
-    createChild(services: ServiceCollection): IInstantiationService;
-}
-/**
- * Identifies a service of type `T`.
- */
-interface ServiceIdentifier<T> {
-    (...args: any[]): void;
-    type: T;
-}
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
-
-interface IRawLanguageExtensionPoint {
-    id: string;
-    extensions: string[];
-    filenames: string[];
-    filenamePatterns: string[];
-    firstLine: string;
-    aliases: string[];
-    mimetypes: string[];
-    configuration: string;
-    icon: {
-        light: string;
-        dark: string;
-    };
-}
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import { I as IInstantiationService } from '../instantiation.js';
+import 'monaco-editor';
 
 /**
  * A workbench contribution that will be loaded when the workbench starts and disposed when the workbench shuts down.
@@ -84,4 +14,4 @@ declare class ExtensionPoints implements IWorkbenchContribution {
 }
 declare function getServiceOverride(): IEditorOverrideServices;
 
-export { ExtensionPoints, IRawLanguageExtensionPoint, getServiceOverride as default };
+export { ExtensionPoints, getServiceOverride as default };

package/dist/service-override/layout.js

@@ -1,24 +1,95 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
 import '../vscode-services/missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { IWorkbenchLayoutService } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { isAncestorUsingFlowTo } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-class LayoutService {
-    constructor(container) {
+import { IPaneCompositePartService } from '../vscode/vs/workbench/services/panecomposite/browser/panecomposite.js';
+let LayoutService = class LayoutService {
+    constructor(container, paneCompositeService) {
         this.container = container;
-        this.onDidChangePartVisibility = Event.None;
+        this.paneCompositeService = paneCompositeService;
+        this.parts = new Map();
+        this.hiddenParts = new Set();
+        this._onDidChangePartVisibility = new Emitter();
+        this.onDidChangePartVisibility = this._onDidChangePartVisibility.event;
         this.offset = { top: 0, quickPickTop: 0 };
         this._onDidLayout = new Emitter();
         this.onDidLayout = this._onDidLayout.event;
         window.addEventListener('resize', () => this.layout());
         this.layout();
     }
-    isVisible() {
+    isPanelMaximized() {
         return false;
     }
+    getPanelPosition() {
+        return 2 ;
+    }
+    hasFocus(part) {
+        const activeElement = document.activeElement;
+        if (activeElement == null) {
+            return false;
+        }
+        const container = this.getContainer(part);
+        return !(container == null) && isAncestorUsingFlowTo(activeElement, container);
+    }
+    getContainer(part) {
+        if (this.parts.get(part) == null) {
+            return undefined;
+        }
+        return this.getPart(part).getContainer();
+    }
+    getPart(key) {
+        const part = this.parts.get(key);
+        if (part == null) {
+            throw new Error(`Unknown part ${key}`);
+        }
+        return part;
+    }
+    setPartHidden(hidden, part) {
+        if (hidden) {
+            this.hiddenParts.add(part);
+        }
+        else {
+            this.hiddenParts.delete(part);
+        }
+        this._onDidChangePartVisibility.fire();
+        const location = {
+            ["workbench.parts.sidebar" ]: 0 ,
+            ["workbench.parts.auxiliarybar" ]: 2 ,
+            ["workbench.parts.panel" ]: 1
+        }[part];
+        if (location != null) {
+            const paneComposite = this.paneCompositeService.getActivePaneComposite(location);
+            if (paneComposite != null) {
+                if (hidden) {
+                    this.paneCompositeService.hideActivePaneComposite(location);
+                }
+            }
+            if (this.paneCompositeService.getPartByLocation != null) {
+                this.paneCompositeService.getPartByLocation(location).setVisible(!hidden);
+            }
+        }
+        setTimeout(() => {
+            this.setPartHidden(false, part);
+        });
+    }
+    isVisible(part) {
+        return !( this.hiddenParts.has(part));
+    }
+    getSideBarPosition() {
+        return 0 ;
+    }
+    registerPart(part) {
+        this.parts.set(part.getId(), part);
+    }
+    isRestored() {
+        return true;
+    }
     get dimension() { return this._dimension; }
     layout() {
         this._dimension = dom.getClientArea(window.document.body);
@@ -30,7 +101,10 @@ class LayoutService {
     focus() {
         StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor()?.focus();
     }
-}
+};
+LayoutService = __decorate([
+    ( __param(1, IPaneCompositePartService))
+], LayoutService);
 function getServiceOverride(container = document.body) {
     container.classList.add('monaco-workbench');
     return {