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

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

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 './update.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './update.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-update-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 - update service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@2.2.0-next.1",
+    "vscode-marked": "npm:marked@=3.0.2"
+  }
+}

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

@@ -0,0 +1,7 @@
+import './vscode/src/vs/workbench/contrib/update/browser/update.contribution.js';
+
+function getServiceOverride() {
+    return {};
+}
+
+export { getServiceOverride as default };

package/vscode/src/vs/platform/update/common/update.config.contribution.js

@@ -0,0 +1,99 @@
+import { isWindows, isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'update',
+    order: 15,
+    title: ( localizeWithPath(
+        'vs/platform/update/common/update.config.contribution',
+        'updateConfigurationTitle',
+        "Update"
+    )),
+    type: 'object',
+    properties: {
+        'update.mode': {
+            type: 'string',
+            enum: ['none', 'manual', 'start', 'default'],
+            default: 'default',
+            scope: 1 ,
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'updateMode',
+                "Configure whether you receive automatic updates. Requires a restart after change. The updates are fetched from a Microsoft online service."
+            )),
+            tags: ['usesOnlineServices'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'none',
+                    "Disable updates."
+                )),
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'manual',
+                    "Disable automatic background update checks. Updates will be available if you manually check for updates."
+                )),
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'start',
+                    "Check for updates only on startup. Disable automatic background update checks."
+                )),
+                ( localizeWithPath(
+                    'vs/platform/update/common/update.config.contribution',
+                    'default',
+                    "Enable automatic update checks. Code will check for updates automatically and periodically."
+                ))
+            ],
+            policy: {
+                name: 'UpdateMode',
+                minimumVersion: '1.67',
+            }
+        },
+        'update.channel': {
+            type: 'string',
+            default: 'default',
+            scope: 1 ,
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'updateMode',
+                "Configure whether you receive automatic updates. Requires a restart after change. The updates are fetched from a Microsoft online service."
+            )),
+            deprecationMessage: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'deprecated',
+                "This setting is deprecated, please use '{0}' instead.",
+                'update.mode'
+            ))
+        },
+        'update.enableWindowsBackgroundUpdates': {
+            type: 'boolean',
+            default: true,
+            scope: 1 ,
+            title: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'enableWindowsBackgroundUpdatesTitle',
+                "Enable Background Updates on Windows"
+            )),
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'enableWindowsBackgroundUpdates',
+                "Enable to download and install new VS Code versions in the background on Windows."
+            )),
+            included: isWindows && !isWeb
+        },
+        'update.showReleaseNotes': {
+            type: 'boolean',
+            default: true,
+            scope: 1 ,
+            description: ( localizeWithPath(
+                'vs/platform/update/common/update.config.contribution',
+                'showReleaseNotes',
+                "Show Release Notes after an update. The Release Notes are fetched from a Microsoft online service."
+            )),
+            tags: ['usesOnlineServices']
+        }
+    }
+});

package/vscode/src/vs/workbench/contrib/update/browser/media/releasenoteseditor.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".file-icons-enabled .show-file-icons .webview-vs_code_release_notes-name-file-icon.file-icon:before{background-image:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMDI0IDEwMjQiPjxwYXRoIGQ9Ik0xMDI0IDEwMjRIMFYwaDEwMjR2MTAyNHoiIHN0eWxlPSJmaWxsOiNmNmY2ZjY7ZmlsbC1vcGFjaXR5OjAiIGZpbGw9Im5vbmUiLz48cGF0aCBkPSJNMTAyNCA4NS4zMzN2ODUzLjMzM0gwVjg1LjMzM2gxMDI0eiIgc3R5bGU9ImZpbGw6I2ZmZiIvPjxwYXRoIGQ9Ik0wIDg1LjMzM2gyOTguNjY3djg1My4zMzNIMFY4NS4zMzN6bTEwMjQgMHY4NTMuMzMzSDM4NFY4NS4zMzNoNjQwem0tNTU0LjY2NyAxNjBoMzQxLjMzM3YtNjRINDY5LjMzM3Y2NHptMzQxLjMzNCA1MzMuMzM0SDQ2OS4zMzN2NjRoMzQxLjMzM2wuMDAxLTY0em0xMjgtMTQ5LjMzNEg1OTcuMzMzdjY0aDM0MS4zMzNsLjAwMS02NHptMC0xNDkuMzMzSDU5Ny4zMzN2NjRoMzQxLjMzM2wuMDAxLTY0em0wLTE0OS4zMzNINTk3LjMzM3Y2NGgzNDEuMzMzbC4wMDEtNjR6IiBzdHlsZT0iZmlsbDojMTY3YWJmIi8+PC9zdmc+\");content:\" \"}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/update/browser/releaseNotesEditor.js

@@ -0,0 +1,283 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/releasenoteseditor.css.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { escapeMarkdownSyntaxTokens } from 'vscode/vscode/vs/base/common/htmlContent';
+import { KeybindingParser } from 'vscode/vscode/vs/base/common/keybindingParser';
+import { escape } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { TokenizationRegistry } from 'vscode/vscode/vs/editor/common/languages';
+import { generateTokensCSSForColorMap } from 'vscode/vscode/vs/editor/common/languages/supports/tokenization';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IRequestService, asTextOrError } from 'vscode/vscode/vs/platform/request/common/request';
+import { renderMarkdownDocument, DEFAULT_MARKDOWN_STYLES } from 'vscode/vscode/vs/workbench/contrib/markdown/browser/markdownDocumentRenderer';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { supportsTelemetry, getTelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+
+let ReleaseNotesManager = class ReleaseNotesManager {
+    constructor(_environmentService, _keybindingService, _languageService, _openerService, _requestService, _configurationService, _editorService, _editorGroupService, _webviewWorkbenchService, _extensionService, _productService) {
+        this._environmentService = _environmentService;
+        this._keybindingService = _keybindingService;
+        this._languageService = _languageService;
+        this._openerService = _openerService;
+        this._requestService = _requestService;
+        this._configurationService = _configurationService;
+        this._editorService = _editorService;
+        this._editorGroupService = _editorGroupService;
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+        this._extensionService = _extensionService;
+        this._productService = _productService;
+        this._releaseNotesCache = ( new Map());
+        this._currentReleaseNotes = undefined;
+        this.disposables = ( new DisposableStore());
+        TokenizationRegistry.onDidChange(async () => {
+            if (!this._currentReleaseNotes || !this._lastText) {
+                return;
+            }
+            const html = await this.renderBody(this._lastText);
+            if (this._currentReleaseNotes) {
+                this._currentReleaseNotes.webview.setHtml(html);
+            }
+        });
+        _configurationService.onDidChangeConfiguration(this.onDidChangeConfiguration, this, this.disposables);
+        _webviewWorkbenchService.onDidChangeActiveWebviewEditor(this.onDidChangeActiveWebviewEditor, this, this.disposables);
+    }
+    async show(version) {
+        const releaseNoteText = await this.loadReleaseNotes(version);
+        this._lastText = releaseNoteText;
+        const html = await this.renderBody(releaseNoteText);
+        const title = ( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'releaseNotesInputName',
+            "Release Notes: {0}",
+            version
+        ));
+        const activeEditorPane = this._editorService.activeEditorPane;
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.setName(title);
+            this._currentReleaseNotes.webview.setHtml(html);
+            this._webviewWorkbenchService.revealWebview(this._currentReleaseNotes, activeEditorPane ? activeEditorPane.group : this._editorGroupService.activeGroup, false);
+        }
+        else {
+            this._currentReleaseNotes = this._webviewWorkbenchService.openWebview({
+                title,
+                options: {
+                    tryRestoreScrollPosition: true,
+                    enableFindWidget: true,
+                    disableServiceWorker: true,
+                },
+                contentOptions: {
+                    localResourceRoots: [],
+                    allowScripts: true
+                },
+                extension: undefined
+            }, 'releaseNotes', title, { group: ACTIVE_GROUP, preserveFocus: false });
+            this._currentReleaseNotes.webview.onDidClickLink(uri => this.onDidClickLink(( URI.parse(uri))));
+            const disposables = ( new DisposableStore());
+            disposables.add(this._currentReleaseNotes.webview.onMessage(e => {
+                if (e.message.type === 'showReleaseNotes') {
+                    this._configurationService.updateValue('update.showReleaseNotes', e.message.value);
+                }
+            }));
+            disposables.add(this._currentReleaseNotes.onWillDispose(() => {
+                disposables.dispose();
+                this._currentReleaseNotes = undefined;
+            }));
+            this._currentReleaseNotes.webview.setHtml(html);
+        }
+        return true;
+    }
+    async loadReleaseNotes(version) {
+        const match = /^(\d+\.\d+)\./.exec(version);
+        if (!match) {
+            throw new Error('not found');
+        }
+        const versionLabel = match[1].replace(/\./g, '_');
+        const baseUrl = 'https://code.visualstudio.com/raw';
+        const url = `${baseUrl}/v${versionLabel}.md`;
+        const unassigned = ( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'unassigned',
+            "unassigned"
+        ));
+        const escapeMdHtml = (text) => {
+            return escape(text).replace(/\\/g, '\\\\');
+        };
+        const patchKeybindings = (text) => {
+            const kb = (match, kb) => {
+                const keybinding = this._keybindingService.lookupKeybinding(kb);
+                if (!keybinding) {
+                    return unassigned;
+                }
+                return keybinding.getLabel() || unassigned;
+            };
+            const kbstyle = (match, kb) => {
+                const keybinding = KeybindingParser.parseKeybinding(kb);
+                if (!keybinding) {
+                    return unassigned;
+                }
+                const resolvedKeybindings = this._keybindingService.resolveKeybinding(keybinding);
+                if (resolvedKeybindings.length === 0) {
+                    return unassigned;
+                }
+                return resolvedKeybindings[0].getLabel() || unassigned;
+            };
+            const kbCode = (match, binding) => {
+                const resolved = kb(match, binding);
+                return resolved ? `<code title="${binding}">${escapeMdHtml(resolved)}</code>` : resolved;
+            };
+            const kbstyleCode = (match, binding) => {
+                const resolved = kbstyle(match, binding);
+                return resolved ? `<code title="${binding}">${escapeMdHtml(resolved)}</code>` : resolved;
+            };
+            return text
+                .replace(/`kb\(([a-z.\d\-]+)\)`/gi, kbCode)
+                .replace(/`kbstyle\(([^\)]+)\)`/gi, kbstyleCode)
+                .replace(/kb\(([a-z.\d\-]+)\)/gi, (match, binding) => escapeMarkdownSyntaxTokens(kb(match, binding)))
+                .replace(/kbstyle\(([^\)]+)\)/gi, (match, binding) => escapeMarkdownSyntaxTokens(kbstyle(match, binding)));
+        };
+        const fetchReleaseNotes = async () => {
+            let text;
+            try {
+                text = await asTextOrError(await this._requestService.request({ url }, CancellationToken.None));
+            }
+            catch {
+                throw new Error('Failed to fetch release notes');
+            }
+            if (!text || !/^#\s/.test(text)) {
+                throw new Error('Invalid release notes');
+            }
+            return patchKeybindings(text);
+        };
+        if (!( this._releaseNotesCache.has(version))) {
+            this._releaseNotesCache.set(version, (async () => {
+                try {
+                    return await fetchReleaseNotes();
+                }
+                catch (err) {
+                    this._releaseNotesCache.delete(version);
+                    throw err;
+                }
+            })());
+        }
+        return this._releaseNotesCache.get(version);
+    }
+    onDidClickLink(uri) {
+        this.addGAParameters(uri, 'ReleaseNotes')
+            .then(updated => this._openerService.open(updated))
+            .then(undefined, onUnexpectedError);
+    }
+    async addGAParameters(uri, origin, experiment = '1') {
+        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
+            if (uri.scheme === 'https' && uri.authority === 'code.visualstudio.com') {
+                return uri.with({ query: `${uri.query ? uri.query + '&' : ''}utm_source=VsCode&utm_medium=${encodeURIComponent(origin)}&utm_content=${encodeURIComponent(experiment)}` });
+            }
+        }
+        return uri;
+    }
+    async renderBody(text) {
+        const nonce = generateUuid();
+        const content = await renderMarkdownDocument(text, this._extensionService, this._languageService, false);
+        const colorMap = TokenizationRegistry.getColorMap();
+        const css = colorMap ? generateTokensCSSForColorMap(colorMap) : '';
+        const showReleaseNotes = Boolean(this._configurationService.getValue('update.showReleaseNotes'));
+        return `<!DOCTYPE html>
+		<html>
+			<head>
+				<base href="https://code.visualstudio.com/raw/">
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src https: data:; media-src https:; style-src 'nonce-${nonce}' https://code.visualstudio.com; script-src 'nonce-${nonce}';">
+				<style nonce="${nonce}">
+					${DEFAULT_MARKDOWN_STYLES}
+					${css}
+					header { display: flex; align-items: center; padding-top: 1em; }
+				</style>
+			</head>
+			<body>
+				${content}
+				<script nonce="${nonce}">
+					const vscode = acquireVsCodeApi();
+					const container = document.createElement('p');
+					container.style.display = 'flex';
+					container.style.alignItems = 'center';
+
+					const input = document.createElement('input');
+					input.type = 'checkbox';
+					input.id = 'showReleaseNotes';
+					input.checked = ${showReleaseNotes};
+					container.appendChild(input);
+
+					const label = document.createElement('label');
+					label.htmlFor = 'showReleaseNotes';
+					label.textContent = '${( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'showOnUpdate',
+            "Show release notes after an update"
+        ))}';
+					container.appendChild(label);
+
+					const beforeElement = document.querySelector("body > h1")?.nextElementSibling;
+					if (beforeElement) {
+						document.body.insertBefore(container, beforeElement);
+					} else {
+						document.body.appendChild(container);
+					}
+
+					window.addEventListener('message', event => {
+						if (event.data.type === 'showReleaseNotes') {
+							input.checked = event.data.value;
+						}
+					});
+
+					input.addEventListener('change', event => {
+						vscode.postMessage({ type: 'showReleaseNotes', value: input.checked }, '*');
+					});
+				</script>
+			</body>
+		</html>`;
+    }
+    onDidChangeConfiguration(e) {
+        if (e.affectsConfiguration('update.showReleaseNotes')) {
+            this.updateWebview();
+        }
+    }
+    onDidChangeActiveWebviewEditor(input) {
+        if (input && input === this._currentReleaseNotes) {
+            this.updateWebview();
+        }
+    }
+    updateWebview() {
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.webview.postMessage({
+                type: 'showReleaseNotes',
+                value: this._configurationService.getValue('update.showReleaseNotes')
+            });
+        }
+    }
+};
+ReleaseNotesManager = ( __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IKeybindingService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IOpenerService)),
+    ( __param(4, IRequestService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IWebviewWorkbenchService)),
+    ( __param(9, IExtensionService)),
+    ( __param(10, IProductService))
+], ReleaseNotesManager));
+
+export { ReleaseNotesManager };