@codingame/monaco-vscode-issue-service-override 2.2.0-next.1

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/index.d.ts

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

package/index.js

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

package/issue.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/issue.js

@@ -0,0 +1,12 @@
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IWorkbenchIssueService } from 'vscode/vscode/vs/workbench/services/issue/common/issue';
+import { WebIssueService } from './vscode/src/vs/workbench/services/issue/browser/issueService.js';
+import './vscode/src/vs/workbench/contrib/issue/browser/issue.contribution.js';
+
+function getServiceOverride() {
+    return {
+        [( IWorkbenchIssueService.toString())]: new SyncDescriptor(WebIssueService, [], false)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

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

package/vscode/src/vs/platform/issue/common/issueReporterUtil.js

@@ -0,0 +1,17 @@
+import { rtrim } from 'vscode/vscode/vs/base/common/strings';
+
+function normalizeGitHubUrl(url) {
+    if (url.endsWith('.git')) {
+        url = url.substr(0, url.length - 4);
+    }
+    url = rtrim(url, '/');
+    if (url.endsWith('/new')) {
+        url = rtrim(url, '/new');
+    }
+    if (url.endsWith('/issues')) {
+        url = rtrim(url, '/issues');
+    }
+    return url;
+}
+
+export { normalizeGitHubUrl };

package/vscode/src/vs/workbench/contrib/issue/browser/issue.contribution.js

@@ -0,0 +1,24 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { BaseIssueContribution } from '../common/issue.contribution.js';
+
+let WebIssueContribution = class WebIssueContribution extends BaseIssueContribution {
+    constructor(productService) {
+        super(productService);
+    }
+};
+WebIssueContribution = ( __decorate([
+    ( __param(0, IProductService))
+], WebIssueContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WebIssueContribution, 3 );
+CommandsRegistry.registerCommand('_issues.getSystemStatus', (accessor) => {
+    return ( localizeWithPath(
+        'vs/workbench/contrib/issue/browser/issue.contribution',
+        'statusUnsupported',
+        "The --status argument is not yet supported in browsers."
+    ));
+});

package/vscode/src/vs/workbench/contrib/issue/common/issue.contribution.js

@@ -0,0 +1,103 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IWorkbenchIssueService } from 'vscode/vscode/vs/workbench/services/issue/common/issue';
+
+const OpenIssueReporterActionId = 'workbench.action.openIssueReporter';
+const OpenIssueReporterApiId = 'vscode.openIssueReporter';
+const OpenIssueReporterCommandMetadata = {
+    description: 'Open the issue reporter and optionally prefill part of the form.',
+    args: [
+        {
+            name: 'options',
+            description: 'Data to use to prefill the issue reporter with.',
+            isOptional: true,
+            schema: {
+                oneOf: [
+                    {
+                        type: 'string',
+                        description: 'The extension id to preselect.'
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            extensionId: {
+                                type: 'string'
+                            },
+                            issueTitle: {
+                                type: 'string'
+                            },
+                            issueBody: {
+                                type: 'string'
+                            }
+                        }
+                    }
+                ]
+            }
+        },
+    ]
+};
+let BaseIssueContribution = class BaseIssueContribution {
+    constructor(productService) {
+        if (!productService.reportIssueUrl) {
+            return;
+        }
+        CommandsRegistry.registerCommand({
+            id: OpenIssueReporterActionId,
+            handler: function (accessor, args) {
+                const data = typeof args === 'string'
+                    ? { extensionId: args }
+                    : Array.isArray(args)
+                        ? { extensionId: args[0] }
+                        : args ?? {};
+                return accessor.get(IWorkbenchIssueService).openReporter(data);
+            },
+            metadata: OpenIssueReporterCommandMetadata
+        });
+        CommandsRegistry.registerCommand({
+            id: OpenIssueReporterApiId,
+            handler: function (accessor, args) {
+                const data = typeof args === 'string'
+                    ? { extensionId: args }
+                    : Array.isArray(args)
+                        ? { extensionId: args[0] }
+                        : args ?? {};
+                return accessor.get(IWorkbenchIssueService).openReporter(data);
+            },
+            metadata: OpenIssueReporterCommandMetadata
+        });
+        const reportIssue = {
+            id: OpenIssueReporterActionId,
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/issue/common/issue.contribution',
+                    { key: 'reportIssueInEnglish', comment: ['Translate this to "Report Issue in English" in all languages please!'] },
+                    "Report Issue..."
+                )),
+                original: 'Report Issue...'
+            },
+            category: Categories.Help
+        };
+        MenuRegistry.appendMenuItem(MenuId.CommandPalette, { command: reportIssue });
+        MenuRegistry.appendMenuItem(MenuId.MenubarHelpMenu, {
+            group: '3_feedback',
+            command: {
+                id: OpenIssueReporterActionId,
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/issue/common/issue.contribution',
+                    { key: 'miReportIssue', comment: ['&& denotes a mnemonic', 'Translate this to "Report Issue in English" in all languages please!'] },
+                    "Report &&Issue"
+                ))
+            },
+            order: 3
+        });
+    }
+};
+BaseIssueContribution = ( __decorate([
+    ( __param(0, IProductService))
+], BaseIssueContribution));
+
+export { BaseIssueContribution };

package/vscode/src/vs/workbench/services/issue/browser/issueService.js

@@ -0,0 +1,99 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { windowOpenNoOpener } from 'vscode/vscode/vs/base/browser/dom';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { userAgent } from 'vscode/vscode/vs/base/common/platform';
+import { normalizeGitHubUrl } from '../../../../platform/issue/common/issueReporterUtil.js';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+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 };