@codingame/monaco-editor-wrapper 4.0.0-next.3 → 4.0.0

package/dist/node_modules/@codingame/monaco-vscode-files-service-override/files.js

@@ -0,0 +1,396 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { FileService } from './vscode/src/vs/platform/files/common/fileService.js';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
+export { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { FileType, createFileSystemProviderError, FileSystemProviderErrorCode, FileSystemProviderError, FilePermission, toFileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
+export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'vscode/vscode/vs/platform/files/common/files';
+import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { extUri } from 'vscode/vscode/vs/base/common/resources';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+export { HTMLFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
+import { relative } from 'vscode/vscode/vs/base/common/path';
+import 'vscode/vscode/vs/workbench/contrib/files/browser/files.contribution';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IndexedDBFileSystemProvider } from './vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
+export { IndexedDB } from 'vscode/vscode/vs/base/browser/indexedDB';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { BufferLogger } from 'vscode/vscode/vs/platform/log/common/bufferLog';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import './vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.js';
+import 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService';
+import { registerServiceInitializePreParticipant, checkServicesNotInitialized } from 'vscode/lifecycle';
+import { logsPath } from 'vscode/workbench';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+class RegisteredFileSystemProvider extends Disposable {
+    constructor(readonly) {
+        super();
+        this.onDidChangeCapabilities = 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(file) {
+        this.files.set(( file.uri.toString()), file);
+        this._onDidChangeFile.fire([{
+                resource: file.uri,
+                type: 1
+            }]);
+        const disposableStore = new DisposableStore();
+        disposableStore.add(toDisposable(() => {
+            if (this.files.get(( file.uri.toString())) === file) {
+                this.files.delete(( file.uri.toString()));
+                this._onDidChangeFile.fire([{
+                        resource: file.uri,
+                        type: 2
+                    }]);
+            }
+        }));
+        disposableStore.add(file.onDidDelete(() => {
+            disposableStore.dispose();
+        }));
+        disposableStore.add(file.onDidChange(() => {
+            this._onDidChangeFile.fire([{
+                    resource: file.uri,
+                    type: 0
+                }]);
+        }));
+        disposableStore.add(file.onDidRename(({ from, to }) => {
+            if (this.files.get(( from.toString())) === file) {
+                this.files.delete(( from.toString()));
+                this._onDidChangeFile.fire([{
+                        resource: from,
+                        type: 2
+                    }]);
+                this.files.set(( to.toString()), file);
+                this._onDidChangeFile.fire([{
+                        resource: to,
+                        type: 1
+                    }]);
+            }
+        }));
+        return disposableStore;
+    }
+    async stat(resource) {
+        const resourceUri = ( resource.toString());
+        const file = this.files.get(resourceUri);
+        if (file != null) {
+            return file.stats();
+        }
+        const handledUris = Array.from(( this.files.keys()));
+        for (const handledUri of handledUris) {
+            if (handledUri.startsWith(resourceUri + '/')) {
+                return {
+                    ctime: Date.now(),
+                    mtime: Date.now(),
+                    size: 0,
+                    type: FileType.Directory
+                };
+            }
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async readdir(resource) {
+        const includedPaths = ( Array.from(( this.files.keys()))
+            .map(uri => relative(resource.path, ( URI.parse(uri)).path)))
+            .filter(path => !path.startsWith('..'));
+        const files = includedPaths.filter(path => !path.includes('/'));
+        const directories = ( includedPaths.filter(path => path.includes('/')).map(path => path.slice(0, path.indexOf('/'))));
+        return [
+            ...( files.map(path => [
+                path,
+                FileType.File
+            ])),
+            ...( directories.map(path => [
+                path,
+                FileType.Directory
+            ]))
+        ];
+    }
+    async readFile(resource) {
+        const file = this.files.get(( resource.toString()));
+        if (file != null) {
+            const data = await file.read();
+            if (data instanceof Uint8Array) {
+                return data;
+            }
+            else {
+                return encoder.encode(data);
+            }
+        }
+        throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    watch() {
+        return Disposable.None;
+    }
+    async writeFile(resource, content) {
+        const file = this.files.get(( resource.toString()));
+        if (file?.write != null) {
+            await file.write(decoder.decode(content));
+            return;
+        }
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async delete(resource) {
+        const file = this.files.get(( resource.toString()));
+        if (file != null) {
+            await file.delete();
+            return;
+        }
+        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async rename(from, to) {
+        const file = this.files.get(( from.toString()));
+        if (file != null) {
+            await file.rename(to);
+            return;
+        }
+        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async mkdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+}
+function isFullfiled(result) {
+    return result.status === 'fulfilled';
+}
+class OverlayFileSystemProvider {
+    constructor() {
+        this.providers = [];
+        this.onDidChangeCapabilities = Event.None;
+        this._onDidChangeFile = new Emitter();
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._onDidChangeOverlays = new Emitter();
+        this.onDidChangeOverlays = this._onDidChangeOverlays.event;
+        this.capabilities = 2  | 1024 ;
+    }
+    register(priority, provider) {
+        const item = { priority, provider };
+        this.providers.push(item);
+        this.providers.sort((a, b) => b.priority - a.priority);
+        const disposableStore = new DisposableStore();
+        disposableStore.add(provider.onDidChangeFile(e => {
+            this._onDidChangeFile.fire(e);
+        }));
+        disposableStore.add({
+            dispose: () => {
+                const index = this.providers.indexOf(item);
+                if (index >= 0) {
+                    this.providers.splice(index, 1);
+                    this._onDidChangeOverlays.fire();
+                }
+            }
+        });
+        this._onDidChangeOverlays.fire();
+        return disposableStore;
+    }
+    get delegates() {
+        return ( this.providers.map(({ provider }) => provider));
+    }
+    async readFromDelegates(caller) {
+        let firstError;
+        for (const delegate of this.delegates) {
+            try {
+                return await caller(delegate);
+            }
+            catch (err) {
+                firstError ?? (firstError = err);
+                if (err instanceof FileSystemProviderError && [
+                    FileSystemProviderErrorCode.NoPermissions,
+                    FileSystemProviderErrorCode.FileNotFound,
+                    FileSystemProviderErrorCode.Unavailable
+                ].includes(err.code)) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw firstError;
+    }
+    async writeToDelegates(resource, caller) {
+        for (const provider of this.delegates) {
+            if (((provider.capabilities & 2048) ) > 0) {
+                continue;
+            }
+            try {
+                return await caller(provider);
+            }
+            catch (err) {
+                if (err instanceof FileSystemProviderError && [
+                    FileSystemProviderErrorCode.NoPermissions,
+                    FileSystemProviderErrorCode.FileNotFound,
+                    FileSystemProviderErrorCode.Unavailable
+                ].includes(err.code)) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async stat(resource) {
+        return this.readFromDelegates(async (delegate) => {
+            const result = await delegate.stat(resource);
+            const readOnly = ((delegate.capabilities & 2048) ) > 0;
+            return {
+                ...result,
+                permissions: result.permissions ?? (readOnly ? FilePermission.Readonly : undefined)
+            };
+        });
+    }
+    async readFile(resource) {
+        return this.readFromDelegates(delegate => delegate.readFile(resource));
+    }
+    async readdir(resource) {
+        const results = await Promise.allSettled(( this.delegates.map(delegate => delegate.readdir(resource))));
+        if (!( results.some(isFullfiled))) {
+            throw results[0].reason;
+        }
+        return Object.entries(Object.fromEntries(( results.filter(isFullfiled).map(result => result.value)).flat()));
+    }
+    watch(resource, opts) {
+        const store = new DisposableStore();
+        for (const delegate of this.delegates) {
+            store.add(delegate.watch(resource, opts));
+        }
+        return store;
+    }
+    async writeFile(resource, content, opts) {
+        await this.writeToDelegates(resource, async (delegate) => {
+            try {
+                const stats = await delegate.stat(resource);
+                if (((stats.permissions ?? 0) & FilePermission.Readonly) > 0) {
+                    throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+                }
+            }
+            catch (err) {
+            }
+            return delegate.writeFile(resource, content, opts);
+        });
+    }
+    async mkdir(resource) {
+        await this.writeToDelegates(resource, delegate => delegate.mkdir(resource));
+    }
+    async delete(resource, opts) {
+        await this.writeToDelegates(resource, delegate => delegate.delete(resource, opts));
+    }
+    async rename(from, to, opts) {
+        await this.writeToDelegates(from, delegate => delegate.rename(from, to, opts));
+    }
+}
+function resourceForError(resource) {
+    if (resource.scheme === Schemas.file) {
+        return resource.fsPath;
+    }
+    return ( resource.toString(true));
+}
+async function mkdirp(provider, directory) {
+    const directoriesToCreate = [];
+    while (!extUri.isEqual(directory, extUri.dirname(directory))) {
+        try {
+            const stat = await provider.stat(directory);
+            if ((stat.type & FileType.Directory) === 0) {
+                throw new Error(localizeWithPath('mkdirExistsError', "Unable to create folder '{0}' that already exists but is not a directory", resourceForError(directory)));
+            }
+            break;
+        }
+        catch (error) {
+            if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
+                throw error;
+            }
+            directoriesToCreate.push(extUri.basename(directory));
+            directory = extUri.dirname(directory);
+        }
+    }
+    for (let i = directoriesToCreate.length - 1; i >= 0; i--) {
+        directory = extUri.joinPath(directory, directoriesToCreate[i]);
+        try {
+            await provider.mkdir(directory);
+        }
+        catch (error) {
+            if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
+                throw error;
+            }
+        }
+    }
+}
+class MkdirpOnWriteInMemoryFileSystemProvider extends InMemoryFileSystemProvider {
+    async writeFile(resource, content, opts) {
+        await mkdirp(this, extUri.dirname(resource));
+        return super.writeFile(resource, content, opts);
+    }
+}
+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/' })));
+var CustomSchemas;
+( (function(CustomSchemas) {
+    CustomSchemas.extensionFile = 'extension-file';
+})(CustomSchemas || (CustomSchemas = {})));
+const providers = {
+    [CustomSchemas.extensionFile]: extensionFileSystemProvider,
+    [logsPath.scheme]: new InMemoryFileSystemProvider(),
+    [Schemas.vscodeUserData]: userDataFileSystemProvider,
+    [Schemas.tmp]: new InMemoryFileSystemProvider(),
+    [Schemas.file]: fileSystemProvider
+};
+let MemoryFileService = class MemoryFileService extends FileService {
+    constructor(logService, telemetryService) {
+        super(logService);
+        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);
+                });
+            }
+            if (provider instanceof IndexedDBFileSystemProvider) {
+                this._register(provider.onReportError(e => telemetryService.publicLog2('indexedDBFileSystemProviderError', e)));
+            }
+        }
+    }
+};
+MemoryFileService = __decorate([
+    ( __param(1, ITelemetryService))
+], MemoryFileService);
+const fileLogger = new BufferLogger();
+registerServiceInitializePreParticipant(async (accessor) => {
+    fileLogger.logger = accessor.get(ILogService);
+});
+async function initFile(file, content, options) {
+    checkServicesNotInitialized();
+    const provider = providers[file.scheme];
+    if (provider == null || provider.writeFile == null) {
+        throw new Error(`${file.scheme} provider doesn't exist or doesn't support writing files`);
+    }
+    if (!(options?.overwrite ?? false)) {
+        try {
+            await provider.stat(file);
+            return;
+        }
+        catch (error) {
+        }
+    }
+    await provider.writeFile(file, content instanceof Uint8Array ? content : encoder.encode(content), {
+        atomic: false,
+        create: true,
+        overwrite: false,
+        unlock: false,
+        ...options
+    });
+}
+
+export { CustomSchemas, IndexedDBFileSystemProvider, RegisteredFileSystemProvider, initFile };

package/dist/node_modules/@codingame/monaco-vscode-files-service-override/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };