@codingame/monaco-vscode-api 1.82.6 → 1.83.1

package/vscode/src/vs/platform/credentials/common/credentials.d.ts

@@ -1,13 +0,0 @@
-interface ICredentialsProvider {
-    getPassword(service: string, account: string): Promise<string | null>;
-    setPassword(service: string, account: string, password: string): Promise<void>;
-    deletePassword(service: string, account: string): Promise<boolean>;
-    findPassword(service: string): Promise<string | null>;
-    findCredentials(service: string): Promise<Array<{
-        account: string;
-        password: string;
-    }>>;
-    clear?(): Promise<void>;
-}
-
-export type { ICredentialsProvider };

package/vscode/src/vs/platform/credentials/common/credentials.js

@@ -1,3 +0,0 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const ICredentialsService = ( createDecorator('credentialsService'));
-export { ICredentialsService };

package/vscode/src/vs/workbench/api/browser/mainThreadKeytar.js

@@ -1,31 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainContext } from '../common/extHost.protocol.js';
-import { ICredentialsService } from '../../../platform/credentials/common/credentials.js';
-let MainThreadKeytar = class MainThreadKeytar {
-    constructor(_extHostContext, _credentialsService) {
-        this._credentialsService = _credentialsService;
-    }
-    async $getPassword(service, account) {
-        return this._credentialsService.getPassword(service, account);
-    }
-    async $setPassword(service, account, password) {
-        return this._credentialsService.setPassword(service, account, password);
-    }
-    async $deletePassword(service, account) {
-        return this._credentialsService.deletePassword(service, account);
-    }
-    async $findPassword(service) {
-        return this._credentialsService.findPassword(service);
-    }
-    async $findCredentials(service) {
-        return this._credentialsService.findCredentials(service);
-    }
-    dispose() {
-    }
-};
-MainThreadKeytar = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadKeytar),
-    ( __param(1, ICredentialsService))
-], MainThreadKeytar);
-export { MainThreadKeytar };

package/vscode/src/vs/workbench/browser/iframe.js

@@ -1,16 +0,0 @@
-async function parentOriginHash(parentOrigin, salt) {
-    if (!crypto.subtle) {
-        throw new Error(`'crypto.subtle' is not available so webviews will not work. This is likely because the editor is not running in a secure context (https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts).`);
-    }
-    const strData = JSON.stringify({ parentOrigin, salt });
-    const encoder = ( new TextEncoder());
-    const arrData = encoder.encode(strData);
-    const hash = await crypto.subtle.digest('sha-256', arrData);
-    return sha256AsBase32(hash);
-}
-function sha256AsBase32(bytes) {
-    const array = Array.from(( new Uint8Array(bytes)));
-    const hexArray = ( array.map(b => ( b.toString(16)).padStart(2, '0'))).join('');
-    return ( BigInt(`0x${hexArray}`).toString(32)).padStart(52, '0');
-}
-export { parentOriginHash };

package/vscode/src/vs/workbench/browser/parts/editor/accessibilityStatus.js

@@ -1,90 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { NotificationPriority, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
-let AccessibilityStatus = class AccessibilityStatus extends Disposable {
-    constructor(configurationService, notificationService, _accessibilityService, statusbarService) {
-        super();
-        this.configurationService = configurationService;
-        this.notificationService = notificationService;
-        this._accessibilityService = _accessibilityService;
-        this.statusbarService = statusbarService;
-        this.screenReaderNotification = null;
-        this.promptedScreenReader = false;
-        this.screenReaderModeElement = this._register(( new MutableDisposable()));
-        this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => this.onScreenReaderModeChange()));
-        this._register(configurationService.onDidChangeConfiguration(c => {
-            if (c.affectsConfiguration('editor.accessibilitySupport')) {
-                this.onScreenReaderModeChange();
-            }
-        }));
-        CommandsRegistry.registerCommand({ id: 'showEditorScreenReaderNotification', handler: () => this.showScreenReaderNotification() });
-        this.updateScreenReaderModeElement(this._accessibilityService.isScreenReaderOptimized());
-    }
-    showScreenReaderNotification() {
-        this.screenReaderNotification = this.notificationService.prompt(Severity.Info, ( localize(
-            'screenReaderDetectedExplanation.question',
-            "Are you using a screen reader to operate VS Code?"
-        )), [{
-                label: ( localize('screenReaderDetectedExplanation.answerYes', "Yes")),
-                run: () => {
-                    this.configurationService.updateValue('editor.accessibilitySupport', 'on', 2 );
-                }
-            }, {
-                label: ( localize('screenReaderDetectedExplanation.answerNo', "No")),
-                run: () => {
-                    this.configurationService.updateValue('editor.accessibilitySupport', 'off', 2 );
-                }
-            }], {
-            sticky: true,
-            priority: NotificationPriority.URGENT
-        });
-        Event.once(this.screenReaderNotification.onDidClose)(() => this.screenReaderNotification = null);
-    }
-    updateScreenReaderModeElement(visible) {
-        if (visible) {
-            if (!this.screenReaderModeElement.value) {
-                const text = ( localize('screenReaderDetected', "Screen Reader Optimized"));
-                this.screenReaderModeElement.value = this.statusbarService.addEntry({
-                    name: ( localize('status.editor.screenReaderMode', "Screen Reader Mode")),
-                    text,
-                    ariaLabel: text,
-                    command: 'showEditorScreenReaderNotification',
-                    kind: 'prominent'
-                }, 'status.editor.screenReaderMode', 1 , 100.6);
-            }
-        }
-        else {
-            this.screenReaderModeElement.clear();
-        }
-    }
-    onScreenReaderModeChange() {
-        const screenReaderDetected = this._accessibilityService.isScreenReaderOptimized();
-        if (screenReaderDetected) {
-            const screenReaderConfiguration = this.configurationService.getValue('editor.accessibilitySupport');
-            if (screenReaderConfiguration === 'auto') {
-                if (!this.promptedScreenReader) {
-                    this.promptedScreenReader = true;
-                    setTimeout(() => this.showScreenReaderNotification(), 100);
-                }
-            }
-        }
-        if (this.screenReaderNotification) {
-            this.screenReaderNotification.close();
-        }
-        this.updateScreenReaderModeElement(this._accessibilityService.isScreenReaderOptimized());
-    }
-};
-AccessibilityStatus = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, INotificationService)),
-    ( __param(2, IAccessibilityService)),
-    ( __param(3, IStatusbarService))
-], AccessibilityStatus));
-export { AccessibilityStatus };

package/vscode/src/vs/workbench/browser/parts/editor/tabFocus.js

@@ -1,77 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { TabFocus } from 'monaco-editor/esm/vs/editor/browser/config/tabFocus.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { terminalTabFocusModeContextKey } from '../../../../platform/terminal/common/terminal.js';
-const editorTabFocusContextKey = ( new RawContextKey('editorTabFocusMode', false, true));
-let TabFocusMode = class TabFocusMode extends Disposable {
-    constructor(contextKeyService, configurationService) {
-        super();
-        this._onDidChange = this._register(( new Emitter()));
-        this.onDidChange = this._onDidChange.event;
-        this._editorContext = editorTabFocusContextKey.bindTo(contextKeyService);
-        this._terminalContext = terminalTabFocusModeContextKey.bindTo(contextKeyService);
-        const editorConfig = configurationService.getValue('editor.tabFocusMode');
-        const terminalConfig = configurationService.getValue("terminal.integrated.tabFocusMode" ) ?? editorConfig;
-        this._editorContext.set(editorConfig);
-        this._terminalContext.set(terminalConfig);
-        TabFocus.setTabFocusMode(editorConfig, "editorFocus" );
-        TabFocus.setTabFocusMode(terminalConfig, "terminalFocus" );
-        const viewKey = ( new Set());
-        viewKey.add('focusedView');
-        this._register(contextKeyService.onDidChangeContext((c) => {
-            if (c.affectsSome(viewKey)) {
-                const terminalFocus = contextKeyService.getContextKeyValue('focusedView') === 'terminal';
-                const context = terminalFocus ? "terminalFocus"  : "editorFocus" ;
-                if (this._previousViewContext === context) {
-                    return;
-                }
-                if (terminalFocus) {
-                    this._editorContext.reset();
-                }
-                else {
-                    this._terminalContext.reset();
-                }
-                this._previousViewContext = context;
-                this._onDidChange.fire();
-            }
-        }));
-        this._register(configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('editor.tabFocusMode')) {
-                const editorConfig = configurationService.getValue('editor.tabFocusMode');
-                TabFocus.setTabFocusMode(editorConfig, "editorFocus" );
-                this._editorContext.set(editorConfig);
-                const terminalConfig = configurationService.getValue("terminal.integrated.tabFocusMode" );
-                if (terminalConfig === null) {
-                    configurationService.updateValue("terminal.integrated.tabFocusMode" , editorConfig);
-                    TabFocus.setTabFocusMode(editorConfig, "terminalFocus" );
-                    this._terminalContext.set(editorConfig);
-                }
-                this._onDidChange.fire();
-            }
-            else if (e.affectsConfiguration("terminal.integrated.tabFocusMode" )) {
-                const terminalConfig = configurationService.getValue("terminal.integrated.tabFocusMode" ) ?? configurationService.getValue('editor.tabFocusMode');
-                configurationService.updateValue("terminal.integrated.tabFocusMode" , terminalConfig);
-                TabFocus.setTabFocusMode(terminalConfig, "terminalFocus" );
-                this._terminalContext.set(terminalConfig);
-                this._onDidChange.fire();
-            }
-        }));
-        TabFocus.onDidChangeTabFocus(() => {
-            const focusedView = contextKeyService.getContextKeyValue('focusedView') === 'terminal' ? "terminalFocus"  : "editorFocus" ;
-            if (focusedView === "terminalFocus" ) {
-                this._terminalContext.set(TabFocus.getTabFocusMode(focusedView));
-            }
-            else {
-                this._editorContext.set(TabFocus.getTabFocusMode(focusedView));
-            }
-        });
-    }
-};
-TabFocusMode = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IConfigurationService))
-], TabFocusMode));
-export { TabFocusMode, editorTabFocusContextKey };

package/vscode/src/vs/workbench/contrib/output/browser/logViewer.js

@@ -1,67 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { basename, dirname } from 'monaco-editor/esm/vs/base/common/path.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { AbstractTextResourceEditor } from '../../../browser/parts/editor/textResourceEditor.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { LOG_SCHEME } from '../../../services/output/common/output.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
-var LogViewerInput_1, LogViewer_1;
-let LogViewerInput = class LogViewerInput extends TextResourceEditorInput {
-    static { LogViewerInput_1 = this; }
-    static { this.ID = 'workbench.editorinputs.output'; }
-    get typeId() {
-        return LogViewerInput_1.ID;
-    }
-    constructor(outputChannelDescriptor, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService) {
-        super(( URI.from({ scheme: LOG_SCHEME, path: outputChannelDescriptor.id })), basename(outputChannelDescriptor.file.path), dirname(outputChannelDescriptor.file.path), undefined, undefined, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService);
-    }
-};
-LogViewerInput = LogViewerInput_1 = ( __decorate([
-    ( __param(1, ITextModelService)),
-    ( __param(2, ITextFileService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IFileService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, IFilesConfigurationService))
-], LogViewerInput));
-let LogViewer = class LogViewer extends AbstractTextResourceEditor {
-    static { LogViewer_1 = this; }
-    static { this.LOG_VIEWER_EDITOR_ID = 'workbench.editors.logViewer'; }
-    constructor(telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService) {
-        super(LogViewer_1.LOG_VIEWER_EDITOR_ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService);
-    }
-    getConfigurationOverrides() {
-        const options = super.getConfigurationOverrides();
-        options.wordWrap = 'off';
-        options.folding = false;
-        options.scrollBeyondLastLine = false;
-        options.renderValidationDecorations = 'editable';
-        return options;
-    }
-    getAriaLabel() {
-        return ( localize('logViewerAriaLabel', "Log viewer"));
-    }
-};
-LogViewer = LogViewer_1 = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, ITextResourceConfigurationService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, IEditorGroupsService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, IFileService))
-], LogViewer));
-export { LogViewer, LogViewerInput };