@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/browser/parts/editor/editorPlaceholder.js

@@ -0,0 +1,235 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/editorplaceholder.css.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { isEditorOpenError } from '../../../common/editor.js';
+import { EditorPane } from './editorPane.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { clearNode, $, EventHelper, size } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { assertAllDefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { isSingleFolderWorkspaceIdentifier, toWorkspaceIdentifier, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { EditorOpenSource } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { EditorPaneDescriptor, computeEditorAriaLabel } from '../../editor.js';
+import { ButtonBar } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { SimpleIconLabel } from '../../../../base/browser/ui/iconLabel/simpleIconLabel.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { truncate } from 'monaco-editor/esm/vs/base/common/strings.js';
+let EditorPlaceholder = class EditorPlaceholder extends EditorPane {
+    constructor(id, telemetryService, themeService, storageService) {
+        super(id, telemetryService, themeService, storageService);
+        this.inputDisposable = this._register(( new MutableDisposable()));
+    }
+    createEditor(parent) {
+        this.container = document.createElement('div');
+        this.container.className = 'monaco-editor-pane-placeholder';
+        this.container.style.outline = 'none';
+        this.container.tabIndex = 0;
+        this.scrollbar = this._register(( new DomScrollableElement(
+            this.container,
+            { horizontal: 1 , vertical: 1  }
+        )));
+        parent.appendChild(this.scrollbar.getDomNode());
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.inputDisposable.value = await this.renderInput(input, options);
+    }
+    async renderInput(input, options) {
+        const [container, scrollbar] = assertAllDefined(this.container, this.scrollbar);
+        clearNode(container);
+        const disposables = ( new DisposableStore());
+        const { icon, label, actions } = await this.getContents(input, options, disposables);
+        const truncatedLabel = truncate(label, EditorPlaceholder.PLACEHOLDER_LABEL_MAX_LENGTH);
+        const iconContainer = container.appendChild($('.editor-placeholder-icon-container'));
+        const iconWidget = ( new SimpleIconLabel(iconContainer));
+        iconWidget.text = icon;
+        const labelContainer = container.appendChild($('.editor-placeholder-label-container'));
+        const labelWidget = document.createElement('span');
+        labelWidget.textContent = truncatedLabel;
+        labelContainer.appendChild(labelWidget);
+        container.setAttribute('aria-label', `${computeEditorAriaLabel(input, undefined, this.group, undefined)}, ${truncatedLabel}`);
+        if (actions.length) {
+            const actionsContainer = container.appendChild($('.editor-placeholder-buttons-container'));
+            const buttons = disposables.add(( new ButtonBar(actionsContainer)));
+            for (let i = 0; i < actions.length; i++) {
+                const button = disposables.add(buttons.addButton({
+                    ...defaultButtonStyles,
+                    secondary: i !== 0
+                }));
+                button.label = actions[i].label;
+                disposables.add(button.onDidClick(e => {
+                    if (e) {
+                        EventHelper.stop(e, true);
+                    }
+                    actions[i].run();
+                }));
+            }
+        }
+        scrollbar.scanDomNode();
+        return disposables;
+    }
+    clearInput() {
+        if (this.container) {
+            clearNode(this.container);
+        }
+        this.inputDisposable.clear();
+        super.clearInput();
+    }
+    layout(dimension) {
+        const [container, scrollbar] = assertAllDefined(this.container, this.scrollbar);
+        size(container, dimension.width, dimension.height);
+        scrollbar.scanDomNode();
+        container.classList.toggle('max-height-200px', dimension.height <= 200);
+    }
+    focus() {
+        const container = assertIsDefined(this.container);
+        container.focus();
+    }
+    dispose() {
+        this.container?.remove();
+        super.dispose();
+    }
+};
+EditorPlaceholder.PLACEHOLDER_LABEL_MAX_LENGTH = 1024;
+EditorPlaceholder = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IStorageService))
+], EditorPlaceholder));
+let WorkspaceTrustRequiredPlaceholderEditor = class WorkspaceTrustRequiredPlaceholderEditor extends EditorPlaceholder {
+    constructor(telemetryService, themeService, commandService, workspaceService, storageService) {
+        super(WorkspaceTrustRequiredPlaceholderEditor.ID, telemetryService, themeService, storageService);
+        this.commandService = commandService;
+        this.workspaceService = workspaceService;
+    }
+    getTitle() {
+        return WorkspaceTrustRequiredPlaceholderEditor.LABEL;
+    }
+    async getContents() {
+        return {
+            icon: '$(workspace-untrusted)',
+            label: isSingleFolderWorkspaceIdentifier(toWorkspaceIdentifier(this.workspaceService.getWorkspace())) ?
+                ( localize(
+                    'requiresFolderTrustText',
+                    "The file is not displayed in the editor because trust has not been granted to the folder."
+                )) :
+                ( localize(
+                    'requiresWorkspaceTrustText',
+                    "The file is not displayed in the editor because trust has not been granted to the workspace."
+                )),
+            actions: [
+                {
+                    label: ( localize('manageTrust', "Manage Workspace Trust")),
+                    run: () => this.commandService.executeCommand('workbench.trust.manage')
+                }
+            ]
+        };
+    }
+};
+WorkspaceTrustRequiredPlaceholderEditor.ID = 'workbench.editors.workspaceTrustRequiredEditor';
+WorkspaceTrustRequiredPlaceholderEditor.LABEL = ( localize('trustRequiredEditor', "Workspace Trust Required"));
+WorkspaceTrustRequiredPlaceholderEditor.DESCRIPTOR = EditorPaneDescriptor.create(WorkspaceTrustRequiredPlaceholderEditor, WorkspaceTrustRequiredPlaceholderEditor.ID, WorkspaceTrustRequiredPlaceholderEditor.LABEL);
+WorkspaceTrustRequiredPlaceholderEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IStorageService))
+], WorkspaceTrustRequiredPlaceholderEditor));
+let ErrorPlaceholderEditor = class ErrorPlaceholderEditor extends EditorPlaceholder {
+    constructor(telemetryService, themeService, storageService, fileService, dialogService) {
+        super(ErrorPlaceholderEditor.ID, telemetryService, themeService, storageService);
+        this.fileService = fileService;
+        this.dialogService = dialogService;
+    }
+    async getContents(input, options, disposables) {
+        const resource = input.resource;
+        const group = this.group;
+        const error = options.error;
+        const isFileNotFound = error?.fileOperationResult === 1 ;
+        let label;
+        if (isFileNotFound) {
+            label = ( localize(
+                'unavailableResourceErrorEditorText',
+                "The editor could not be opened because the file was not found."
+            ));
+        }
+        else if (isEditorOpenError(error) && error.forceMessage) {
+            label = error.message;
+        }
+        else if (error) {
+            label = ( localize(
+                'unknownErrorEditorTextWithError',
+                "The editor could not be opened due to an unexpected error: {0}",
+                toErrorMessage(error)
+            ));
+        }
+        else {
+            label = ( localize(
+                'unknownErrorEditorTextWithoutError',
+                "The editor could not be opened due to an unexpected error."
+            ));
+        }
+        let icon = '$(error)';
+        if (isEditorOpenError(error)) {
+            if (error.forceSeverity === Severity.Info) {
+                icon = '$(info)';
+            }
+            else if (error.forceSeverity === Severity.Warning) {
+                icon = '$(warning)';
+            }
+        }
+        let actions = undefined;
+        if (isEditorOpenError(error) && error.actions.length > 0) {
+            actions = ( error.actions.map(action => {
+                return {
+                    label: action.label,
+                    run: () => {
+                        const result = action.run();
+                        if (result instanceof Promise) {
+                            result.catch(error => this.dialogService.error(toErrorMessage(error)));
+                        }
+                    }
+                };
+            }));
+        }
+        else if (group) {
+            actions = [
+                {
+                    label: ( localize('retry', "Try Again")),
+                    run: () => group.openEditor(input, { ...options, source: EditorOpenSource.USER  })
+                }
+            ];
+        }
+        if (group && isFileNotFound && resource && this.fileService.hasProvider(resource)) {
+            disposables.add(this.fileService.onDidFilesChange(e => {
+                if (e.contains(resource, 1 , 0 )) {
+                    group.openEditor(input, options);
+                }
+            }));
+        }
+        return { icon, label, actions: actions ?? [] };
+    }
+};
+ErrorPlaceholderEditor.ID = 'workbench.editors.errorEditor';
+ErrorPlaceholderEditor.LABEL = ( localize('errorEditor', "Error Editor"));
+ErrorPlaceholderEditor.DESCRIPTOR = EditorPaneDescriptor.create(ErrorPlaceholderEditor, ErrorPlaceholderEditor.ID, ErrorPlaceholderEditor.LABEL);
+ErrorPlaceholderEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IDialogService))
+], ErrorPlaceholderEditor));
+export { EditorPlaceholder, ErrorPlaceholderEditor, WorkspaceTrustRequiredPlaceholderEditor };

package/dist/vscode/vs/workbench/browser/parts/editor/editorQuickAccess.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/editorquickaccess.css";
+import './media/editorquickaccess.css.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { quickPickItemScorerAccessor } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
 import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';