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

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

@@ -1,6 +1,14 @@
 import * as monaco from 'monaco-editor';
 import * as vscode from 'vscode';
 
+/**
+ * Identifies a service of type `T`.
+ */
+interface ServiceIdentifier<T> {
+    (...args: any[]): void;
+    type: T;
+}
+
 /**
  * An object that performs a cleanup operation when `.dispose()` is called.
  *
@@ -529,6 +537,33 @@ interface IRelativePattern {
     readonly pattern: string;
 }
 
+declare enum LogLevel {
+    Off = 0,
+    Trace = 1,
+    Debug = 2,
+    Info = 3,
+    Warning = 4,
+    Error = 5
+}
+interface ILogger extends IDisposable {
+    onDidChangeLogLevel: Event<LogLevel>;
+    getLevel(): LogLevel;
+    setLevel(level: LogLevel): void;
+    trace(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string | Error, ...args: any[]): void;
+    /**
+     * An operation to flush the contents. Can be synchronous.
+     */
+    flush(): void;
+}
+declare const ILogService: ServiceIdentifier<ILogService>;
+interface ILogService extends ILogger {
+    readonly _serviceBrand: undefined;
+}
+
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
 interface ReadableStreamEvents<T> {
@@ -779,6 +814,9 @@ interface IFileSystemProviderWithFileReadWriteCapability extends IFileSystemProv
     readFile(resource: URI): Promise<Uint8Array>;
     writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
 }
+interface IFileSystemProviderWithFileReadStreamCapability extends IFileSystemProvider {
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+}
 declare enum FileSystemProviderErrorCode {
     FileExists = "EntryExists",
     FileNotFound = "EntryNotFound",
@@ -822,6 +860,55 @@ interface IFileChange {
     readonly resource: URI;
 }
 
+declare class IndexedDB {
+    private readonly name;
+    static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
+    private static openDatabase;
+    private static doOpenDatabase;
+    private static deleteDatabase;
+    private database;
+    private readonly pendingTransactions;
+    constructor(database: IDBDatabase, name: string);
+    hasPendingTransactions(): boolean;
+    close(): void;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>[]): Promise<T[]>;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
+    getKeyValues<V>(store: string, isValid: (value: unknown) => value is V): Promise<Map<string, V>>;
+}
+
+declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability {
+    private indexedDB;
+    private readonly store;
+    private logService;
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<any>;
+    private extUri;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    constructor(indexedDB: IndexedDB | undefined, store: string, logService: ILogService);
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    private readonly _files;
+    private readonly _directories;
+    registerFileHandle(handle: FileSystemFileHandle): Promise<URI>;
+    registerDirectoryHandle(handle: FileSystemDirectoryHandle): Promise<URI>;
+    get directories(): Iterable<FileSystemDirectoryHandle>;
+    private registerHandle;
+    getHandle(resource: URI): Promise<FileSystemHandle | undefined>;
+    private getFileHandle;
+    private getDirectoryHandle;
+    private doGetHandle;
+    private toFileSystemProviderError;
+    private createFileSystemProviderError;
+}
+
 declare abstract class SimpleTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
     onDidChangeCapabilities: Event<any>;
     capabilities: number;
@@ -833,13 +920,13 @@ declare abstract class SimpleTextFileSystemProvider implements IFileSystemProvid
     watch(): IDisposable;
     stat(resource: URI): Promise<IStat>;
     mkdir(): Promise<void>;
-    readdir(): Promise<[string, FileType][]>;
+    readdir(directory: URI): Promise<[string, FileType][]>;
     delete(): Promise<void>;
     rename(): Promise<void>;
     onDidWatchError: Event<any>;
 }
 declare function getServiceOverride(): IEditorOverrideServices;
-declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string>): IDisposable;
+declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
 declare function registerFileSystemOverlay(provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-export { FileChangeType, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FileChangeType, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

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/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 {

package/dist/service-override/modelEditor.js

@@ -110,7 +110,9 @@ let EditorService = class EditorService extends Disposable {
         if (options != null) {
             applyTextEditorOptions(options, modelEditor, 1 );
         }
-        modelEditor.focus();
+        if (!(options?.preserveFocus ?? false)) {
+            modelEditor.focus();
+        }
         return new SimpleEditorPane(modelEditor);
     }
 };