@codingame/monaco-vscode-host-service-override 1.85.2

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/host.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/host.js

@@ -0,0 +1,14 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IHostColorSchemeService } from 'vscode/vscode/vs/workbench/services/themes/common/hostColorSchemeService';
+import { BrowserHostService } from './vscode/src/vs/workbench/services/host/browser/browserHostService.js';
+import { BrowserHostColorSchemeService } from './vscode/src/vs/workbench/services/themes/browser/browserHostColorSchemeService.js';
+
+function getServiceOverride() {
+    return {
+        [( IHostService.toString())]: new SyncDescriptor(BrowserHostService, [], true),
+        [( IHostColorSchemeService.toString())]: new SyncDescriptor(BrowserHostColorSchemeService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './host.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './host.js';

package/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 };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@codingame/monaco-vscode-host-service-override",
+  "version": "1.85.2",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - host service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.2",
+    "monaco-editor": "0.45.0"
+  }
+}

package/vscode/src/vs/workbench/services/host/browser/browserHostService.js

@@ -0,0 +1,410 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { isFolderToOpen, isWorkspaceToOpen, isFileToOpen } from 'vscode/vscode/vs/platform/window/common/window';
+import { pathsToEditors, isResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
+import { whenEditorClosed } from 'vscode/vscode/vs/workbench/browser/editor';
+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 { ModifierKeyEmitter, onDidRegisterWindow, trackFocus, getActiveDocument, getWindowId, disposableWindowInterval } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { parseLineAndColumnAware } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { getWorkspaceIdentifier } from 'vscode/vscode/vs/workbench/services/workspaces/browser/workspaces';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+import { isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isTemporaryWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { mainWindow, isAuxiliaryWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var HostShutdownReason;
+( (function(HostShutdownReason) {
+    HostShutdownReason[HostShutdownReason["Unknown"] = 1] = "Unknown";
+    HostShutdownReason[HostShutdownReason["Keyboard"] = 2] = "Keyboard";
+    HostShutdownReason[HostShutdownReason["Api"] = 3] = "Api";
+})(HostShutdownReason || (HostShutdownReason = {})));
+let BrowserHostService = class BrowserHostService extends Disposable {
+    constructor(layoutService, configurationService, fileService, labelService, environmentService, instantiationService, lifecycleService, logService, dialogService, contextService, userDataProfileService) {
+        super();
+        this.layoutService = layoutService;
+        this.configurationService = configurationService;
+        this.fileService = fileService;
+        this.labelService = labelService;
+        this.environmentService = environmentService;
+        this.instantiationService = instantiationService;
+        this.lifecycleService = lifecycleService;
+        this.logService = logService;
+        this.dialogService = dialogService;
+        this.contextService = contextService;
+        this.userDataProfileService = userDataProfileService;
+        this.shutdownReason = HostShutdownReason.Unknown;
+        if (environmentService.options?.workspaceProvider) {
+            this.workspaceProvider = environmentService.options.workspaceProvider;
+        }
+        else {
+            this.workspaceProvider = new class {
+                constructor() {
+                    this.workspace = undefined;
+                    this.trusted = undefined;
+                }
+                async open() { return true; }
+            };
+        }
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.lifecycleService.onBeforeShutdown(e => this.onBeforeShutdown(e)));
+        this._register(ModifierKeyEmitter.getInstance().event(() => this.updateShutdownReasonFromEvent()));
+    }
+    onBeforeShutdown(e) {
+        switch (this.shutdownReason) {
+            case HostShutdownReason.Unknown:
+            case HostShutdownReason.Keyboard: {
+                const confirmBeforeClose = this.configurationService.getValue('window.confirmBeforeClose');
+                if (confirmBeforeClose === 'always' || (confirmBeforeClose === 'keyboardOnly' && this.shutdownReason === HostShutdownReason.Keyboard)) {
+                    e.veto(true, 'veto.confirmBeforeClose');
+                }
+                break;
+            }
+        }
+        this.shutdownReason = HostShutdownReason.Unknown;
+    }
+    updateShutdownReasonFromEvent() {
+        if (this.shutdownReason === HostShutdownReason.Api) {
+            return;
+        }
+        if (ModifierKeyEmitter.getInstance().isModifierPressed) {
+            this.shutdownReason = HostShutdownReason.Keyboard;
+        }
+        else {
+            this.shutdownReason = HostShutdownReason.Unknown;
+        }
+    }
+    get onDidChangeFocus() {
+        const emitter = this._register(( new Emitter()));
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
+            const focusTracker = disposables.add(trackFocus(window));
+            const visibilityTracker = disposables.add(( new DomEmitter(window.document, 'visibilitychange')));
+            Event.any(( Event.map(focusTracker.onDidFocus, () => this.hasFocus, disposables)), ( Event.map(focusTracker.onDidBlur, () => this.hasFocus, disposables)), ( Event.map(visibilityTracker.event, () => this.hasFocus, disposables)), ( Event.map(this.onDidChangeActiveWindow, () => this.hasFocus, disposables)))(focus => emitter.fire(focus));
+        }, { window: mainWindow, disposables: this._store }));
+        return Event.latch(emitter.event, undefined, this._store);
+    }
+    get hasFocus() {
+        return getActiveDocument().hasFocus();
+    }
+    async hadLastFocus() {
+        return true;
+    }
+    async focus(targetWindow) {
+        targetWindow.focus();
+    }
+    get onDidChangeActiveWindow() {
+        const emitter = this._register(( new Emitter()));
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
+            const windowId = getWindowId(window);
+            const focusTracker = disposables.add(trackFocus(window));
+            disposables.add(focusTracker.onDidFocus(() => emitter.fire(windowId)));
+            if (isAuxiliaryWindow(window)) {
+                disposables.add(disposableWindowInterval(window, () => {
+                    const hasFocus = window.document.hasFocus();
+                    if (hasFocus) {
+                        emitter.fire(windowId);
+                    }
+                    return hasFocus;
+                }, 100, 20));
+            }
+        }, { window: mainWindow, disposables: this._store }));
+        return Event.latch(emitter.event, undefined, this._store);
+    }
+    openWindow(arg1, arg2) {
+        if (Array.isArray(arg1)) {
+            return this.doOpenWindow(arg1, arg2);
+        }
+        return this.doOpenEmptyWindow(arg1);
+    }
+    async doOpenWindow(toOpen, options) {
+        const payload = this.preservePayload(false );
+        const fileOpenables = [];
+        const foldersToAdd = [];
+        for (const openable of toOpen) {
+            openable.label = openable.label || this.getRecentLabel(openable);
+            if (isFolderToOpen(openable)) {
+                if (options?.addMode) {
+                    foldersToAdd.push(({ uri: openable.folderUri }));
+                }
+                else {
+                    this.doOpen({ folderUri: openable.folderUri }, { reuse: this.shouldReuse(options, false ), payload });
+                }
+            }
+            else if (isWorkspaceToOpen(openable)) {
+                this.doOpen({ workspaceUri: openable.workspaceUri }, { reuse: this.shouldReuse(options, false ), payload });
+            }
+            else if (isFileToOpen(openable)) {
+                fileOpenables.push(openable);
+            }
+        }
+        if (foldersToAdd.length > 0) {
+            this.withServices(accessor => {
+                const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+                workspaceEditingService.addFolders(foldersToAdd);
+            });
+        }
+        if (fileOpenables.length > 0) {
+            this.withServices(async (accessor) => {
+                const editorService = accessor.get(IEditorService);
+                if (options?.mergeMode && fileOpenables.length === 4) {
+                    const editors = coalesce(await pathsToEditors(fileOpenables, this.fileService, this.logService));
+                    if (editors.length !== 4 || !isResourceEditorInput(editors[0]) || !isResourceEditorInput(editors[1]) || !isResourceEditorInput(editors[2]) || !isResourceEditorInput(editors[3])) {
+                        return;
+                    }
+                    if (this.shouldReuse(options, true )) {
+                        editorService.openEditor({
+                            input1: { resource: editors[0].resource },
+                            input2: { resource: editors[1].resource },
+                            base: { resource: editors[2].resource },
+                            result: { resource: editors[3].resource },
+                            options: { pinned: true }
+                        });
+                    }
+                    else {
+                        const environment = ( new Map());
+                        environment.set('mergeFile1', ( editors[0].resource.toString()));
+                        environment.set('mergeFile2', ( editors[1].resource.toString()));
+                        environment.set('mergeFileBase', ( editors[2].resource.toString()));
+                        environment.set('mergeFileResult', ( editors[3].resource.toString()));
+                        this.doOpen(undefined, { payload: Array.from(environment.entries()) });
+                    }
+                }
+                if (options?.diffMode && fileOpenables.length === 2) {
+                    const editors = coalesce(await pathsToEditors(fileOpenables, this.fileService, this.logService));
+                    if (editors.length !== 2 || !isResourceEditorInput(editors[0]) || !isResourceEditorInput(editors[1])) {
+                        return;
+                    }
+                    if (this.shouldReuse(options, true )) {
+                        editorService.openEditor({
+                            original: { resource: editors[0].resource },
+                            modified: { resource: editors[1].resource },
+                            options: { pinned: true }
+                        });
+                    }
+                    else {
+                        const environment = ( new Map());
+                        environment.set('diffFileSecondary', ( editors[0].resource.toString()));
+                        environment.set('diffFilePrimary', ( editors[1].resource.toString()));
+                        this.doOpen(undefined, { payload: Array.from(environment.entries()) });
+                    }
+                }
+                else {
+                    for (const openable of fileOpenables) {
+                        if (this.shouldReuse(options, true )) {
+                            let openables = [];
+                            if (options?.gotoLineMode) {
+                                const pathColumnAware = parseLineAndColumnAware(openable.fileUri.path);
+                                openables = [{
+                                        fileUri: openable.fileUri.with({ path: pathColumnAware.path }),
+                                        options: {
+                                            selection: !isUndefined(pathColumnAware.line) ? { startLineNumber: pathColumnAware.line, startColumn: pathColumnAware.column || 1 } : undefined
+                                        }
+                                    }];
+                            }
+                            else {
+                                openables = [openable];
+                            }
+                            editorService.openEditors(coalesce(await pathsToEditors(openables, this.fileService, this.logService)), undefined, { validateTrust: true });
+                        }
+                        else {
+                            const environment = ( new Map());
+                            environment.set('openFile', ( openable.fileUri.toString()));
+                            if (options?.gotoLineMode) {
+                                environment.set('gotoLineMode', 'true');
+                            }
+                            this.doOpen(undefined, { payload: Array.from(environment.entries()) });
+                        }
+                    }
+                }
+                const waitMarkerFileURI = options?.waitMarkerFileURI;
+                if (waitMarkerFileURI) {
+                    (async () => {
+                        await this.instantiationService.invokeFunction(accessor => whenEditorClosed(accessor, ( fileOpenables.map(fileOpenable => fileOpenable.fileUri))));
+                        await this.fileService.del(waitMarkerFileURI);
+                    })();
+                }
+            });
+        }
+    }
+    withServices(fn) {
+        this.instantiationService.invokeFunction(accessor => fn(accessor));
+    }
+    preservePayload(isEmptyWindow) {
+        const newPayload = ( new Array());
+        if (!isEmptyWindow && this.environmentService.extensionDevelopmentLocationURI) {
+            newPayload.push(['extensionDevelopmentPath', ( this.environmentService.extensionDevelopmentLocationURI.toString())]);
+            if (this.environmentService.debugExtensionHost.debugId) {
+                newPayload.push(['debugId', this.environmentService.debugExtensionHost.debugId]);
+            }
+            if (this.environmentService.debugExtensionHost.port) {
+                newPayload.push(['inspect-brk-extensions', String(this.environmentService.debugExtensionHost.port)]);
+            }
+        }
+        if (!this.userDataProfileService.currentProfile.isDefault) {
+            newPayload.push(['lastActiveProfile', this.userDataProfileService.currentProfile.id]);
+        }
+        return newPayload.length ? newPayload : undefined;
+    }
+    getRecentLabel(openable) {
+        if (isFolderToOpen(openable)) {
+            return this.labelService.getWorkspaceLabel(openable.folderUri, { verbose: 2  });
+        }
+        if (isWorkspaceToOpen(openable)) {
+            return this.labelService.getWorkspaceLabel(getWorkspaceIdentifier(openable.workspaceUri), { verbose: 2  });
+        }
+        return this.labelService.getUriLabel(openable.fileUri);
+    }
+    shouldReuse(options = Object.create(null), isFile) {
+        if (options.waitMarkerFileURI) {
+            return true;
+        }
+        const windowConfig = this.configurationService.getValue('window');
+        const openInNewWindowConfig = isFile ? ((windowConfig?.openFilesInNewWindow || 'off') ) : ((windowConfig?.openFoldersInNewWindow || 'default') );
+        let openInNewWindow = (options.preferNewWindow || !!options.forceNewWindow) && !options.forceReuseWindow;
+        if (!options.forceNewWindow && !options.forceReuseWindow && (openInNewWindowConfig === 'on' || openInNewWindowConfig === 'off')) {
+            openInNewWindow = (openInNewWindowConfig === 'on');
+        }
+        return !openInNewWindow;
+    }
+    async doOpenEmptyWindow(options) {
+        return this.doOpen(undefined, {
+            reuse: options?.forceReuseWindow,
+            payload: this.preservePayload(true )
+        });
+    }
+    async doOpen(workspace, options) {
+        if (workspace && isFolderToOpen(workspace) && workspace.folderUri.scheme === Schemas.file && isTemporaryWorkspace(this.contextService.getWorkspace())) {
+            this.withServices(async (accessor) => {
+                const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+                await workspaceEditingService.updateFolders(0, this.contextService.getWorkspace().folders.length, [{ uri: workspace.folderUri }]);
+            });
+            return;
+        }
+        if (options?.reuse) {
+            await this.handleExpectedShutdown(4 );
+        }
+        const opened = await this.workspaceProvider.open(workspace, options);
+        if (!opened) {
+            const { confirmed } = await this.dialogService.confirm({
+                type: Severity.Warning,
+                message: ( localizeWithPath(
+                    'vs/workbench/services/host/browser/browserHostService',
+                    'unableToOpenExternal',
+                    "The browser interrupted the opening of a new tab or window. Press 'Open' to open it anyway."
+                )),
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/host/browser/browserHostService',
+                    { key: 'open', comment: ['&& denotes a mnemonic'] },
+                    "&&Open"
+                ))
+            });
+            if (confirmed) {
+                await this.workspaceProvider.open(workspace, options);
+            }
+        }
+    }
+    async toggleFullScreen(targetWindow) {
+        const target = this.layoutService.getContainer(targetWindow);
+        if (targetWindow.document.fullscreen !== undefined) {
+            if (!targetWindow.document.fullscreen) {
+                try {
+                    return await target.requestFullscreen();
+                }
+                catch (error) {
+                    this.logService.warn('toggleFullScreen(): requestFullscreen failed');
+                }
+            }
+            else {
+                try {
+                    return await targetWindow.document.exitFullscreen();
+                }
+                catch (error) {
+                    this.logService.warn('toggleFullScreen(): exitFullscreen failed');
+                }
+            }
+        }
+        if (targetWindow.document.webkitIsFullScreen !== undefined) {
+            try {
+                if (!targetWindow.document.webkitIsFullScreen) {
+                    target.webkitRequestFullscreen();
+                }
+                else {
+                    targetWindow.document.webkitExitFullscreen();
+                }
+            }
+            catch {
+                this.logService.warn('toggleFullScreen(): requestFullscreen/exitFullscreen failed');
+            }
+        }
+    }
+    async moveTop(targetWindow) {
+    }
+    async getCursorScreenPoint() {
+        return undefined;
+    }
+    async restart() {
+        this.reload();
+    }
+    async reload() {
+        await this.handleExpectedShutdown(3 );
+        mainWindow.location.reload();
+    }
+    async close() {
+        await this.handleExpectedShutdown(1 );
+        mainWindow.close();
+    }
+    async withExpectedShutdown(expectedShutdownTask) {
+        const previousShutdownReason = this.shutdownReason;
+        try {
+            this.shutdownReason = HostShutdownReason.Api;
+            return await expectedShutdownTask();
+        }
+        finally {
+            this.shutdownReason = previousShutdownReason;
+        }
+    }
+    async handleExpectedShutdown(reason) {
+        this.shutdownReason = HostShutdownReason.Api;
+        return this.lifecycleService.withExpectedShutdown(reason);
+    }
+};
+BrowserHostService.__decorator = ( __decorate([
+    memoize
+], BrowserHostService.prototype, "onDidChangeFocus", null));
+BrowserHostService.__decorator = ( __decorate([
+    memoize
+], BrowserHostService.prototype, "onDidChangeActiveWindow", null));
+BrowserHostService = ( __decorate([
+    ( __param(0, ILayoutService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IFileService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IBrowserWorkbenchEnvironmentService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ILifecycleService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IDialogService)),
+    ( __param(9, IWorkspaceContextService)),
+    ( __param(10, IUserDataProfileService))
+], BrowserHostService));
+
+export { BrowserHostService };

package/vscode/src/vs/workbench/services/themes/browser/browserHostColorSchemeService.js

@@ -0,0 +1,40 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { addMatchMediaChangeListener } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+
+class BrowserHostColorSchemeService extends Disposable {
+    constructor() {
+        super();
+        this._onDidSchemeChangeEvent = this._register(( new Emitter()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        addMatchMediaChangeListener('(prefers-color-scheme: dark)', () => {
+            this._onDidSchemeChangeEvent.fire();
+        });
+        addMatchMediaChangeListener('(forced-colors: active)', () => {
+            this._onDidSchemeChangeEvent.fire();
+        });
+    }
+    get onDidChangeColorScheme() {
+        return this._onDidSchemeChangeEvent.event;
+    }
+    get dark() {
+        if (mainWindow.matchMedia(`(prefers-color-scheme: light)`).matches) {
+            return false;
+        }
+        else if (mainWindow.matchMedia(`(prefers-color-scheme: dark)`).matches) {
+            return true;
+        }
+        return false;
+    }
+    get highContrast() {
+        if (mainWindow.matchMedia(`(forced-colors: active)`).matches) {
+            return true;
+        }
+        return false;
+    }
+}
+
+export { BrowserHostColorSchemeService };