@codingame/monaco-vscode-dialogs-service-override 4.3.1 → 4.4.0

package/dialogs.d.ts

@@ -1,5 +1,12 @@
 import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
 
-declare function getServiceOverride(): IEditorOverrideServices;
+interface DialogServiceOverrideProps {
+    /**
+     * Is an `HTMLFileSystemProvider` is used as only provider for the `file` scheme directly (without overlay)
+     * Enable this option to enable browser file dialogs
+     */
+    useHtmlFileSystemProvider: boolean;
+}
+declare function getServiceOverride({ useHtmlFileSystemProvider }: DialogServiceOverrideProps): IEditorOverrideServices;
 
 export { getServiceOverride as default };

package/dialogs.js

@@ -2,12 +2,13 @@ import { DialogService } from './vscode/src/vs/workbench/services/dialogs/common
 import './override/vs/platform/dialogs/common/dialogs.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { AbstractFileDialogService } from './vscode/src/vs/workbench/services/dialogs/browser/abstractFileDialogService.js';
+import { FileDialogService } from './vscode/src/vs/workbench/services/dialogs/browser/fileDialogService.js';
 import { unsupported } from './tools.js';
 import './vscode/src/vs/workbench/browser/parts/dialogs/dialog.web.contribution.js';
 import './vscode/src/vs/workbench/contrib/welcomeDialog/browser/welcomeDialog.contribution.js';
 import { IDialogService, IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
-class FileDialogService extends AbstractFileDialogService {
+class DialogServiceOverride extends AbstractFileDialogService {
     constructor() {
         super(...arguments);
         this.pickWorkspaceAndOpen = unsupported;
@@ -47,10 +48,10 @@ class FileDialogService extends AbstractFileDialogService {
         return super.pickFileToSaveSimplified(schema, options);
     }
 }
-function getServiceOverride() {
+function getServiceOverride({ useHtmlFileSystemProvider }) {
     return {
         [( IDialogService.toString())]: new SyncDescriptor(DialogService, undefined, true),
-        [( IFileDialogService.toString())]: new SyncDescriptor(FileDialogService, undefined, true)
+        [( IFileDialogService.toString())]: useHtmlFileSystemProvider ? new SyncDescriptor(FileDialogService, undefined, true) : new SyncDescriptor(DialogServiceOverride, undefined, true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-dialogs-service-override",
-  "version": "4.3.1",
+  "version": "4.4.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.3.1"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.4.0"
   }
 }

package/vscode/src/vs/workbench/services/dialogs/browser/fileDialogService.js

@@ -0,0 +1,244 @@
+import { __decorate } from 'vscode/external/tslib/tslib.es6.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { AbstractFileDialogService } from './abstractFileDialogService.js';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { memoize } from 'vscode/vscode/vs/base/common/decorators';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { getMediaOrTextMime } from 'vscode/vscode/vs/base/common/mime';
+import { basename } from 'vscode/vscode/vs/base/common/resources';
+import { getActiveWindow, triggerDownload, triggerUpload } from 'vscode/vscode/vs/base/browser/dom';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { extractFileListData } from 'vscode/vscode/vs/platform/dnd/browser/dnd';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { WebFileSystemAccess } from 'vscode/vscode/vs/platform/files/browser/webFileSystemAccess';
+import { EmbeddedCodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget';
+
+class FileDialogService extends AbstractFileDialogService {
+    get fileSystemProvider() {
+        return this.fileService.getProvider(Schemas.file);
+    }
+    async pickFileFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickFileFolderAndOpenSimplified(schema, options, false);
+        }
+        throw new Error(localizeWithPath('vs/workbench/services/dialogs/browser/fileDialogService', 'pickFolderAndOpen', "Can't open folders, try adding a folder to the workspace instead."));
+    }
+    addFileSchemaIfNeeded(schema, isFolder) {
+        return (schema === Schemas.untitled) ? [Schemas.file]
+            : (((schema !== Schemas.file) && (!isFolder || (schema !== Schemas.vscodeRemote))) ? [schema, Schemas.file] : [schema]);
+    }
+    async pickFileAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickFileAndOpenSimplified(schema, options, false);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('open');
+        }
+        let fileHandle = undefined;
+        try {
+            ([fileHandle] = await activeWindow.showOpenFilePicker({ multiple: false }));
+        }
+        catch (error) {
+            return;
+        }
+        if (!WebFileSystemAccess.isFileSystemFileHandle(fileHandle)) {
+            return;
+        }
+        const uri = await this.fileSystemProvider.registerFileHandle(fileHandle);
+        this.addFileToRecentlyOpened(uri);
+        await this.openerService.open(uri, { fromUserGesture: true, editorOptions: { pinned: true } });
+    }
+    async pickFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultFolderPath(schema);
+        }
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickFolderAndOpenSimplified(schema, options);
+        }
+        throw new Error(localizeWithPath('vs/workbench/services/dialogs/browser/fileDialogService', 'pickFolderAndOpen', "Can't open folders, try adding a folder to the workspace instead."));
+    }
+    async pickWorkspaceAndOpen(options) {
+        options.availableFileSystems = this.getWorkspaceAvailableFileSystems(options);
+        const schema = this.getFileSystemSchema(options);
+        if (!options.defaultUri) {
+            options.defaultUri = await this.defaultWorkspacePath(schema);
+        }
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickWorkspaceAndOpenSimplified(schema, options);
+        }
+        throw new Error(localizeWithPath('vs/workbench/services/dialogs/browser/fileDialogService', 'pickWorkspaceAndOpen', "Can't open workspaces, try adding a folder to the workspace instead."));
+    }
+    async pickFileToSave(defaultUri, availableFileSystems) {
+        const schema = this.getFileSystemSchema({ defaultUri, availableFileSystems });
+        const options = this.getPickFileToSaveDialogOptions(defaultUri, availableFileSystems);
+        if (this.shouldUseSimplified(schema)) {
+            return super.pickFileToSaveSimplified(schema, options);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('save');
+        }
+        let fileHandle = undefined;
+        const startIn = Iterable.first(this.fileSystemProvider.directories);
+        try {
+            fileHandle = await activeWindow.showSaveFilePicker({ types: this.getFilePickerTypes(options.filters), ...{ suggestedName: basename(defaultUri), startIn } });
+        }
+        catch (error) {
+            return;
+        }
+        if (!WebFileSystemAccess.isFileSystemFileHandle(fileHandle)) {
+            return undefined;
+        }
+        return this.fileSystemProvider.registerFileHandle(fileHandle);
+    }
+    getFilePickerTypes(filters) {
+        return filters?.filter(filter => {
+            return !((filter.extensions.length === 1) && ((filter.extensions[0] === '*') || filter.extensions[0] === ''));
+        }).map(filter => {
+            const accept = {};
+            const extensions = filter.extensions.filter(ext => (ext.indexOf('-') < 0) && (ext.indexOf('*') < 0) && (ext.indexOf('_') < 0));
+            accept[getMediaOrTextMime(`fileName.${filter.extensions[0]}`) ?? 'text/plain'] = ( extensions.map(ext => ext.startsWith('.') ? ext : `.${ext}`));
+            return {
+                description: filter.name,
+                accept
+            };
+        });
+    }
+    async showSaveDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (this.shouldUseSimplified(schema)) {
+            return super.showSaveDialogSimplified(schema, options);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('save');
+        }
+        let fileHandle = undefined;
+        const startIn = Iterable.first(this.fileSystemProvider.directories);
+        try {
+            fileHandle = await activeWindow.showSaveFilePicker({ types: this.getFilePickerTypes(options.filters), ...(options.defaultUri ? { suggestedName: basename(options.defaultUri) } : undefined), ...{ startIn } });
+        }
+        catch (error) {
+            return undefined;
+        }
+        if (!WebFileSystemAccess.isFileSystemFileHandle(fileHandle)) {
+            return undefined;
+        }
+        return this.fileSystemProvider.registerFileHandle(fileHandle);
+    }
+    async showOpenDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (this.shouldUseSimplified(schema)) {
+            return super.showOpenDialogSimplified(schema, options);
+        }
+        const activeWindow = getActiveWindow();
+        if (!WebFileSystemAccess.supported(activeWindow)) {
+            return this.showUnsupportedBrowserWarning('open');
+        }
+        let uri;
+        const startIn = Iterable.first(this.fileSystemProvider.directories) ?? 'documents';
+        try {
+            if (options.canSelectFiles) {
+                const handle = await activeWindow.showOpenFilePicker({ multiple: false, types: this.getFilePickerTypes(options.filters), ...{ startIn } });
+                if (handle.length === 1 && WebFileSystemAccess.isFileSystemFileHandle(handle[0])) {
+                    uri = await this.fileSystemProvider.registerFileHandle(handle[0]);
+                }
+            }
+            else {
+                const handle = await activeWindow.showDirectoryPicker({ ...{ startIn } });
+                uri = await this.fileSystemProvider.registerDirectoryHandle(handle);
+            }
+        }
+        catch (error) {
+        }
+        return uri ? [uri] : undefined;
+    }
+    async showUnsupportedBrowserWarning(context) {
+        if (context === 'save') {
+            const activeCodeEditor = this.codeEditorService.getActiveCodeEditor();
+            if (!(activeCodeEditor instanceof EmbeddedCodeEditorWidget)) {
+                const activeTextModel = activeCodeEditor?.getModel();
+                if (activeTextModel) {
+                    triggerDownload(VSBuffer.fromString(activeTextModel.getValue()).buffer, basename(activeTextModel.uri));
+                    return;
+                }
+            }
+        }
+        const buttons = [
+            {
+                label: ( localizeWithPath(
+                    'vs/workbench/services/dialogs/browser/fileDialogService',
+                    { key: 'openRemote', comment: ['&& denotes a mnemonic'] },
+                    "&&Open Remote..."
+                )),
+                run: async () => { await this.commandService.executeCommand('workbench.action.remote.showMenu'); }
+            },
+            {
+                label: ( localizeWithPath(
+                    'vs/workbench/services/dialogs/browser/fileDialogService',
+                    { key: 'learnMore', comment: ['&& denotes a mnemonic'] },
+                    "&&Learn More"
+                )),
+                run: async () => { await this.openerService.open('https://aka.ms/VSCodeWebLocalFileSystemAccess'); }
+            }
+        ];
+        if (context === 'open') {
+            buttons.push({
+                label: ( localizeWithPath(
+                    'vs/workbench/services/dialogs/browser/fileDialogService',
+                    { key: 'openFiles', comment: ['&& denotes a mnemonic'] },
+                    "Open &&Files..."
+                )),
+                run: async () => {
+                    const files = await triggerUpload();
+                    if (files) {
+                        const filesData = (await this.instantiationService.invokeFunction(accessor => extractFileListData(accessor, files))).filter(fileData => !fileData.isDirectory);
+                        if (filesData.length > 0) {
+                            this.editorService.openEditors(( filesData.map(fileData => {
+                                return {
+                                    resource: fileData.resource,
+                                    contents: fileData.contents?.toString(),
+                                    options: { pinned: true }
+                                };
+                            })));
+                        }
+                    }
+                }
+            });
+        }
+        await this.dialogService.prompt({
+            type: Severity$1.Warning,
+            message: ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/fileDialogService',
+                'unsupportedBrowserMessage',
+                "Opening Local Folders is Unsupported"
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/dialogs/browser/fileDialogService',
+                'unsupportedBrowserDetail',
+                "Your browser doesn't support opening local folders.\nYou can either open single files or open a remote repository."
+            )),
+            buttons
+        });
+        return undefined;
+    }
+    shouldUseSimplified(scheme) {
+        return ![Schemas.file, Schemas.vscodeUserData, Schemas.tmp].includes(scheme);
+    }
+}
+FileDialogService.__decorator = ( __decorate([
+    memoize
+], FileDialogService.prototype, "fileSystemProvider", null));
+
+export { FileDialogService };