@codingame/monaco-vscode-api 1.79.7-next.0 → 1.79.7-next.1

package/dist/event.d.ts

@@ -583,4 +583,4 @@ interface IWaitUntil {
     waitUntil(thenable: Promise<unknown>): void;
 }
 
-export { CancellationToken as C, Disposable as D, Event as E, IReference as I, IDisposable as a, DisposableStore as b, Emitter as c, IWaitUntil as d };
+export { CancellationToken as C, Disposable as D, Event as E, IReference as I, IDisposable as a, Emitter as b, DisposableStore as c, IWaitUntil as d };

package/dist/languageFeatures.d.ts

@@ -1,5 +1,5 @@
 import { S as ServiceIdentifier, a as ServicesAccessor, I as IInstantiationService } from './instantiation.js';
-import { E as Event, a as IDisposable, C as CancellationToken, c as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
+import { E as Event, a as IDisposable, C as CancellationToken, b as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
 import { I as IJSONSchema } from './jsonSchema.js';
 import { c as ITextModel, P as Position, R as Range, S as Selection, h as IRange, E as EndOfLineSequence, g as IPosition, i as IMarkdownString, j as ISingleEditOperation, k as EditorAutoIndentStrategy, I as IEditorOptions, l as IEditorModel, m as IDimension, n as ITextEditorModel, o as ITextSnapshot, p as ITextBufferFactory, q as IDiffEditor, r as IBaseTextResourceEditorInput, s as IBaseUntypedEditorInput, t as IResourceEditorInput, u as ITextResourceEditorInput } from './editorBrowser.js';
 import { S as Severity$1 } from './severity.js';

package/dist/monaco.d.ts

@@ -1,7 +1,7 @@
 import * as monaco from 'monaco-editor';
 import { I as IEditorOverrideServices } from './standaloneServices.js';
 import { E as Event, D as Disposable, a as IDisposable, I as IReference } from './event.js';
-export { b as DisposableStore } from './event.js';
+export { c as DisposableStore } from './event.js';
 import { c as ITextModel, d as IModelDecorationOptions, e as IModelDecorationsChangeAccessor, f as IEditorContribution, b as ICodeEditor, g as IPosition } from './editorBrowser.js';
 import { L as LanguageFeatureRegistry, I as ILanguageFeaturesService, F as FoldingRangeProvider, a as ILanguageConfigurationService, b as INotificationService, c as ITextFileEditorModel } from './languageFeatures.js';
 export { C as CommandsRegistry, r as registerColor } from './languageFeatures.js';

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

@@ -1,5 +1,5 @@
 import { U as URI } from '../uri.js';
-import { D as Disposable, E as Event, a as IDisposable, C as CancellationToken } from '../event.js';
+import { D as Disposable, E as Event, a as IDisposable, C as CancellationToken, b as Emitter } from '../event.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
 import { I as IFileSystemProviderWithFileReadWriteCapability, F as FileSystemProviderCapabilities, a as IStat, b as FileType, c as IFileWriteOptions, d as IFileOverwriteOptions, e as IFileDeleteOptions, f as IFileChange, g as IWatchOptions, h as IFileSystemProviderWithFileReadStreamCapability, i as IFileReadStreamOptions, R as ReadableStreamEvents } from '../files.js';
 export { l as FileChangeType, m as FilePermission, j as FileSystemProviderError, k as FileSystemProviderErrorCode } from '../files.js';
@@ -103,16 +103,17 @@ declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadW
 
 declare class StaticFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
     private files;
-    constructor();
     capabilities: number;
+    constructor(readonly: boolean);
     onDidChangeCapabilities: Event<any>;
-    onDidChangeFile: Event<any>;
-    registerFile(resource: URI, getContent: () => Promise<string | Uint8Array>): IDisposable;
+    _onDidChangeFile: Emitter<readonly IFileChange[]>;
+    onDidChangeFile: Event<readonly IFileChange[]>;
+    registerFile(resource: URI, getContent: () => Promise<string | Uint8Array>, setContent?: (content: string) => Promise<void>): IDisposable;
     stat(resource: URI): Promise<IStat>;
     readdir(resource: URI): Promise<[string, FileType][]>;
     readFile(resource: URI): Promise<Uint8Array>;
     watch(): IDisposable;
-    writeFile(): Promise<never>;
+    writeFile(resource: URI, content: Uint8Array): Promise<void>;
     mkdir(): Promise<never>;
     delete(): Promise<never>;
     rename(): Promise<never>;

package/dist/service-override/files.js

@@ -17,8 +17,9 @@ export { HTMLFileSystemProvider } from 'monaco-editor/esm/vs/platform/files/brow
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
 class StaticFile {
-    constructor(getContent) {
+    constructor(getContent, setContent) {
         this.getContent = getContent;
+        this.setContent = setContent;
         this.ctime = Date.now();
         this.mtime = Date.now();
         this.size = 0;
@@ -26,36 +27,51 @@ class StaticFile {
     }
 }
 const encoder = new TextEncoder();
+const decoder = new TextDecoder();
 class StaticFileSystemProvider extends Disposable {
-    constructor() {
+    constructor(readonly) {
         super();
-        this.capabilities = 2  | 1024  | 2048 ;
+        this.readonly = readonly;
         this.onDidChangeCapabilities = Event.None;
-        this.onDidChangeFile = Event.None;
+        this._onDidChangeFile = new Emitter();
+        this.onDidChangeFile = this._onDidChangeFile.event;
         this.files = new Map();
+        this.capabilities = 2  | 1024 ;
+        if (readonly) {
+            this.capabilities |= 2048 ;
+        }
     }
-    registerFile(resource, getContent) {
-        this.files.set(( resource.toString()), new StaticFile(getContent));
+    registerFile(resource, getContent, setContent) {
+        this.files.set(( resource.toString()), new StaticFile(getContent, setContent));
+        this._onDidChangeFile.fire([{
+                resource,
+                type: 1
+            }]);
         return {
             dispose: () => {
                 this.files.delete(( resource.toString()));
+                this._onDidChangeFile.fire([{
+                        resource,
+                        type: 2
+                    }]);
             }
         };
     }
     async stat(resource) {
         const resourceUri = ( resource.toString(true));
+        const file = this.files.get(resourceUri);
+        if (file != null) {
+            return {
+                ctime: Date.now(),
+                mtime: Date.now(),
+                size: 0,
+                type: FileType.File,
+                permissions: file.setContent == null || this.readonly ? FilePermission.Readonly : undefined
+            };
+        }
         const handledUris = Array.from(( this.files.keys()));
         for (const handledUri of handledUris) {
-            if (handledUri === resourceUri) {
-                return {
-                    ctime: Date.now(),
-                    mtime: Date.now(),
-                    size: 0,
-                    type: FileType.File,
-                    permissions: FilePermission.Readonly
-                };
-            }
-            else if (handledUri.startsWith(resourceUri + '/')) {
+            if (handledUri.startsWith(resourceUri + '/')) {
                 return {
                     ctime: Date.now(),
                     mtime: Date.now(),
@@ -99,7 +115,16 @@ class StaticFileSystemProvider extends Disposable {
     watch() {
         return Disposable.None;
     }
-    async writeFile() {
+    async writeFile(resource, content) {
+        const file = this.files.get(( resource.toString()));
+        if (file?.setContent != null) {
+            await file.setContent(decoder.decode(content));
+            this._onDidChangeFile.fire([{
+                    resource,
+                    type: 0
+                }]);
+            return;
+        }
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
     async mkdir() {
@@ -165,9 +190,30 @@ class OverlayFileSystemProvider {
         }
         throw firstError;
     }
-    async writeToDelegates(caller) {
-        const firstWritableProvider = this.delegates.find(provider => ((provider.capabilities & 2048) ) === 0);
-        return caller(firstWritableProvider);
+    async writeToDelegates(resource, caller) {
+        for (const provider of this.delegates) {
+            if (((provider.capabilities & 2048) ) > 0) {
+                continue;
+            }
+            try {
+                const stats = await provider.stat(resource);
+                if (((stats.permissions ?? 0) & FilePermission.Readonly) > 0) {
+                    continue;
+                }
+            }
+            catch (err) {
+            }
+            try {
+                return await caller(provider);
+            }
+            catch (err) {
+                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.NoPermissions) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw createFileSystemProviderError('File not writable', FileSystemProviderErrorCode.NoPermissions);
     }
     async stat(resource) {
         return this.readFromDelegates(delegate => delegate.stat(resource));
@@ -190,16 +236,16 @@ class OverlayFileSystemProvider {
         return store;
     }
     async writeFile(resource, content, opts) {
-        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
+        await this.writeToDelegates(resource, delegate => delegate.writeFile(resource, content, opts));
     }
     async mkdir(resource) {
-        await this.writeToDelegates(delegate => delegate.mkdir(resource));
+        await this.writeToDelegates(resource, delegate => delegate.mkdir(resource));
     }
     async delete(resource, opts) {
-        await this.writeToDelegates(delegate => delegate.delete(resource, opts));
+        await this.writeToDelegates(resource, delegate => delegate.delete(resource, opts));
     }
     async rename(from, to, opts) {
-        await this.writeToDelegates(delegate => delegate.rename(from, to, opts));
+        await this.writeToDelegates(from, delegate => delegate.rename(from, to, opts));
     }
 }
 class MkdirpOnWriteInMemoryFileSystemProvider extends InMemoryFileSystemProvider {
@@ -209,7 +255,7 @@ class MkdirpOnWriteInMemoryFileSystemProvider extends InMemoryFileSystemProvider
     }
 }
 const fileSystemProvider = new OverlayFileSystemProvider(new MkdirpOnWriteInMemoryFileSystemProvider());
-const extensionFileSystemProvider = new StaticFileSystemProvider();
+const extensionFileSystemProvider = new StaticFileSystemProvider(true);
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);

package/dist/services.d.ts

@@ -1,6 +1,6 @@
 /// <reference path="./debugProtocol.d.ts" />
 
-import { E as Event$1, a as IDisposable, C as CancellationToken, D as Disposable, c as Emitter } from './event.js';
+import { E as Event$1, a as IDisposable, C as CancellationToken, D as Disposable, b as Emitter } from './event.js';
 import { i as IMarkdownString, l as IEditorModel, p as ITextBufferFactory, c as ITextModel, v as ITextModelCreationOptions, w as IEditor, q as IDiffEditor, t as IResourceEditorInput, u as ITextResourceEditorInput, I as IEditorOptions, x as IResourceEditorInputIdentifier, h as IRange, g as IPosition, P as Position$1, y as IDocumentDiffProviderOptions, z as IDocumentDiff, A as IChange, b as ICodeEditor, B as IBoundarySashes, O as Orientation, C as IDiffEditor$1, D as IDecorationRenderOptions, d as IModelDecorationOptions } from './editorBrowser.js';
 export { F as ITextModelContentProvider, G as ITextModelService, M as MarkdownStringTrustedOptions } from './editorBrowser.js';
 import { S as ServiceIdentifier, c as IConstructorSignature, I as IInstantiationService, B as BrandedService, a as ServicesAccessor } from './instantiation.js';

package/dist/typescript.js

@@ -4,7 +4,7 @@ import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { registerFileSystemOverlay, StaticFileSystemProvider } from './service-override/files.js';
 class TypescriptWorkerFileSystemProvider extends StaticFileSystemProvider {
     constructor() {
-        super();
+        super(true);
         this.updateLibs = () => {
             this.libDisposable?.dispose();
             const disposable = new DisposableStore();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.79.7-next.0",
+  "version": "1.79.7-next.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],