@codingame/monaco-editor-wrapper 4.0.0 → 5.0.0

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

@@ -1,396 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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 };