@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,428 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter, Event } from '../../../../base/common/event.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { isFolderToOpen, isWorkspaceToOpen, isFileToOpen } from '../../../../platform/window/common/window.js';
-import { pathsToEditors, isResourceEditorInput } from '../../../common/editor.js';
-import { whenEditorClosed } from '../../../browser/editor.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { ILabelService } from '../../../../platform/label/common/label.js';
-import { ModifierKeyEmitter, onDidRegisterWindow, trackFocus, getActiveDocument, getWindowId, disposableWindowInterval, EventType, addDisposableListener, addDisposableThrottledListener, detectFullscreen } from '../../../../base/browser/dom.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
-import { memoize } from '../../../../base/common/decorators.js';
-import { parseLineAndColumnAware } from '../../../../base/common/extpath.js';
-import { IWorkspaceEditingService } from '../../workspaces/common/workspaceEditing.js';
-import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { getWorkspaceIdentifier } from '../../workspaces/browser/workspaces.js';
-import { localizeWithPath } from '../../../../nls.js';
-import Severity$1 from '../../../../base/common/severity.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { DomEmitter } from '../../../../base/browser/event.js';
-import { isUndefined } from '../../../../base/common/types.js';
-import { isTemporaryWorkspace, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-import { coalesce } from '../../../../base/common/arrays.js';
-import { mainWindow, isAuxiliaryWindow } from '../../../../base/browser/window.js';
-import { isMacintosh, isIOS } from '../../../../base/common/platform.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-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);
-    }
-    get onDidChangeFullScreen() {
-        const emitter = this._register(( new Emitter()));
-        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
-            const windowId = getWindowId(window);
-            const viewport = isIOS && window.visualViewport ? window.visualViewport  : window ;
-            const isFullScreen = () => {
-                const fullScreen = detectFullscreen(window);
-                return fullScreen !== null && !fullScreen.guess;
-            };
-            for (const event of [EventType.FULLSCREEN_CHANGE, EventType.WK_FULLSCREEN_CHANGE]) {
-                disposables.add(addDisposableListener(window.document, event, () => emitter.fire({ windowId, fullscreen: isFullScreen() })));
-            }
-            disposables.add(addDisposableThrottledListener(viewport, EventType.RESIZE, () => emitter.fire({ windowId, fullscreen: isFullScreen() }), undefined, isMacintosh ? 2000  : 800 ));
-        }, { window: mainWindow, disposables: this._store }));
-        return emitter.event;
-    }
-    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()) });
-                    }
-                }
-                else 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$1.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.__decorator = ( __decorate([
-    memoize
-], BrowserHostService.prototype, "onDidChangeFullScreen", 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/issue/browser/issueService.js

@@ -1,97 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { windowOpenNoOpener } from '../../../../base/browser/dom.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
-import { toDisposable } from '../../../../base/common/lifecycle.js';
-import { userAgent } from '../../../../base/common/platform.js';
-import { normalizeGitHubUrl } from '../../../../platform/issue/common/issueReporterUtil.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { IProductService } from '../../../../platform/product/common/productService.js';
-import { IExtensionService } from '../../extensions/common/extensions.js';
-let WebIssueService = class WebIssueService {
-    constructor(extensionService, productService, logService) {
-        this.extensionService = extensionService;
-        this.productService = productService;
-        this.logService = logService;
-        this._handlers = ( new Map());
-        this._providers = ( new Map());
-    }
-    async openProcessExplorer() {
-        console.error('openProcessExplorer is not implemented in web');
-    }
-    async openReporter(options) {
-        const extensionId = options.extensionId;
-        if (!extensionId) {
-            if (this.productService.reportIssueUrl) {
-                const uri = this.getIssueUriFromStaticContent(this.productService.reportIssueUrl);
-                windowOpenNoOpener(uri);
-                return;
-            }
-            throw new Error(`No issue reporting URL configured for ${this.productService.nameLong}.`);
-        }
-        if (( this._handlers.has(extensionId))) {
-            try {
-                const uri = await this.getIssueUriFromHandler(extensionId, CancellationToken.None);
-                windowOpenNoOpener(uri);
-                return;
-            }
-            catch (e) {
-                this.logService.error(e);
-            }
-        }
-        const selectedExtension = this.extensionService.extensions.filter(ext => ext.identifier.value === options.extensionId)[0];
-        const extensionGitHubUrl = this.getExtensionGitHubUrl(selectedExtension);
-        if (!extensionGitHubUrl) {
-            throw new Error(`Unable to find issue reporting url for ${extensionId}`);
-        }
-        const uri = this.getIssueUriFromStaticContent(`${extensionGitHubUrl}/issues/new`, selectedExtension);
-        windowOpenNoOpener(uri);
-    }
-    registerIssueUriRequestHandler(extensionId, handler) {
-        this._handlers.set(extensionId, handler);
-        return toDisposable(() => this._handlers.delete(extensionId));
-    }
-    registerIssueDataProvider(extensionId, handler) {
-        this._providers.set(extensionId, handler);
-        return toDisposable(() => this._providers.delete(extensionId));
-    }
-    async getIssueUriFromHandler(extensionId, token) {
-        const handler = this._handlers.get(extensionId);
-        if (!handler) {
-            throw new Error(`No handler registered for extension ${extensionId}`);
-        }
-        const result = await handler.provideIssueUrl(token);
-        return ( result.toString(true));
-    }
-    getExtensionGitHubUrl(extension) {
-        if (extension.isBuiltin && this.productService.reportIssueUrl) {
-            return normalizeGitHubUrl(this.productService.reportIssueUrl);
-        }
-        let repositoryUrl = '';
-        const bugsUrl = extension?.bugs?.url;
-        const extensionUrl = extension?.repository?.url;
-        if (bugsUrl && bugsUrl.match(/^https?:\/\/github\.com\/(.*)/)) {
-            repositoryUrl = normalizeGitHubUrl(bugsUrl);
-        }
-        else if (extensionUrl && extensionUrl.match(/^https?:\/\/github\.com\/(.*)/)) {
-            repositoryUrl = normalizeGitHubUrl(extensionUrl);
-        }
-        return repositoryUrl;
-    }
-    getIssueUriFromStaticContent(baseUri, extension) {
-        const issueDescription = `ADD ISSUE DESCRIPTION HERE
-
-Version: ${this.productService.version}
-Commit: ${this.productService.commit ?? 'unknown'}
-User Agent: ${userAgent ?? 'unknown'}
-Embedder: ${this.productService.embedderIdentifier ?? 'unknown'}
-${extension?.version ? `\nExtension version: ${extension.version}` : ''}
-<!-- generated by web issue reporter -->`;
-        return `${baseUri}?body=${encodeURIComponent(issueDescription)}&labels=web`;
-    }
-};
-WebIssueService = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IProductService)),
-    ( __param(2, ILogService))
-], WebIssueService));
-export { WebIssueService };