@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/timeline/common/timelineService.js

@@ -0,0 +1,106 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { TimelinePaneId } from './timeline.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+const TimelineHasProviderContext = ( new RawContextKey('timelineHasProvider', false));
+let TimelineService = class TimelineService {
+    constructor(logService, viewsService, configurationService, contextKeyService) {
+        this.logService = logService;
+        this.viewsService = viewsService;
+        this.configurationService = configurationService;
+        this.contextKeyService = contextKeyService;
+        this._onDidChangeProviders = ( new Emitter());
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
+        this._onDidChangeTimeline = ( new Emitter());
+        this.onDidChangeTimeline = this._onDidChangeTimeline.event;
+        this._onDidChangeUri = ( new Emitter());
+        this.onDidChangeUri = this._onDidChangeUri.event;
+        this.providers = ( new Map());
+        this.providerSubscriptions = ( new Map());
+        this.hasProviderContext = TimelineHasProviderContext.bindTo(this.contextKeyService);
+        this.updateHasProviderContext();
+    }
+    getSources() {
+        return ( [...( this.providers.values())].map(p => ({ id: p.id, label: p.label })));
+    }
+    getTimeline(id, uri, options, tokenSource) {
+        this.logService.trace(`TimelineService#getTimeline(${id}): uri=${( uri.toString())}`);
+        const provider = this.providers.get(id);
+        if (provider === undefined) {
+            return undefined;
+        }
+        if (typeof provider.scheme === 'string') {
+            if (provider.scheme !== '*' && provider.scheme !== uri.scheme) {
+                return undefined;
+            }
+        }
+        else if (!provider.scheme.includes(uri.scheme)) {
+            return undefined;
+        }
+        return {
+            result: provider.provideTimeline(uri, options, tokenSource.token)
+                .then(result => {
+                if (result === undefined) {
+                    return undefined;
+                }
+                result.items = ( result.items.map(item => ({ ...item, source: provider.id })));
+                result.items.sort((a, b) => (b.timestamp - a.timestamp) || b.source.localeCompare(a.source, undefined, { numeric: true, sensitivity: 'base' }));
+                return result;
+            }),
+            options: options,
+            source: provider.id,
+            tokenSource: tokenSource,
+            uri: uri
+        };
+    }
+    registerTimelineProvider(provider) {
+        this.logService.trace(`TimelineService#registerTimelineProvider: id=${provider.id}`);
+        const id = provider.id;
+        const existing = this.providers.get(id);
+        if (existing) {
+            try {
+                existing?.dispose();
+            }
+            catch { }
+        }
+        this.providers.set(id, provider);
+        this.updateHasProviderContext();
+        if (provider.onDidChange) {
+            this.providerSubscriptions.set(id, provider.onDidChange(e => this._onDidChangeTimeline.fire(e)));
+        }
+        this._onDidChangeProviders.fire({ added: [id] });
+        return {
+            dispose: () => {
+                this.providers.delete(id);
+                this._onDidChangeProviders.fire({ removed: [id] });
+            }
+        };
+    }
+    unregisterTimelineProvider(id) {
+        this.logService.trace(`TimelineService#unregisterTimelineProvider: id=${id}`);
+        if (!( this.providers.has(id))) {
+            return;
+        }
+        this.providers.delete(id);
+        this.providerSubscriptions.delete(id);
+        this.updateHasProviderContext();
+        this._onDidChangeProviders.fire({ removed: [id] });
+    }
+    setUri(uri) {
+        this.viewsService.openView(TimelinePaneId, true);
+        this._onDidChangeUri.fire(uri);
+    }
+    updateHasProviderContext() {
+        this.hasProviderContext.set(this.providers.size !== 0);
+    }
+};
+TimelineService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IViewsService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextKeyService))
+], TimelineService));
+export { TimelineHasProviderContext, TimelineService };

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

@@ -0,0 +1,4 @@
+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,411 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/releasenoteseditor.css.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { escapeMarkdownSyntaxTokens } from '../../../../base/common/htmlContent.js';
+import { KeybindingParser } from '../../../../base/common/keybindingParser.js';
+import { escape } from '../../../../base/common/strings.js';
+import { URI } from '../../../../base/common/uri.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { TokenizationRegistry } from '../../../../editor/common/languages.js';
+import { generateTokensCSSForColorMap } from '../../../../editor/common/languages/supports/tokenization.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { IRequestService, asTextOrError } from '../../../../platform/request/common/request.js';
+import { renderMarkdownDocument, DEFAULT_MARKDOWN_STYLES } from '../../markdown/browser/markdownDocumentRenderer.js';
+import { IWebviewWorkbenchService } from '../../webviewPanel/browser/webviewWorkbenchService.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { ACTIVE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { supportsTelemetry, getTelemetryLevel } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { SimpleSettingRenderer } from '../../markdown/browser/markdownSettingRenderer.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+let ReleaseNotesManager = class ReleaseNotesManager {
+    constructor(_environmentService, _keybindingService, _languageService, _openerService, _requestService, _configurationService, _editorService, _editorGroupService, _codeEditorService, _webviewWorkbenchService, _extensionService, _productService, _instantiationService) {
+        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._codeEditorService = _codeEditorService;
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+        this._extensionService = _extensionService;
+        this._productService = _productService;
+        this._instantiationService = _instantiationService;
+        this._releaseNotesCache = ( new Map());
+        this._currentReleaseNotes = undefined;
+        this.disposables = ( new DisposableStore());
+        TokenizationRegistry.onDidChange(() => {
+            return this.updateHtml();
+        });
+        _configurationService.onDidChangeConfiguration(this.onDidChangeConfiguration, this, this.disposables);
+        _webviewWorkbenchService.onDidChangeActiveWebviewEditor(this.onDidChangeActiveWebviewEditor, this, this.disposables);
+        this._simpleSettingRenderer = this._instantiationService.createInstance(SimpleSettingRenderer);
+    }
+    async updateHtml() {
+        if (!this._currentReleaseNotes || !this._lastText) {
+            return;
+        }
+        const html = await this.renderBody(this._lastText);
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.webview.setHtml(html);
+        }
+    }
+    async show(version, useCurrentFile) {
+        const releaseNoteText = await this.loadReleaseNotes(version, useCurrentFile);
+        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);
+                }
+                else if (e.message.type === 'clickSetting') {
+                    const x = this._currentReleaseNotes?.webview.container.offsetLeft + e.message.value.x;
+                    const y = this._currentReleaseNotes?.webview.container.offsetTop + e.message.value.y;
+                    this._simpleSettingRenderer.updateSetting(( URI.parse(e.message.value.uri)), x, y);
+                }
+            }));
+            disposables.add(this._currentReleaseNotes.onWillDispose(() => {
+                disposables.dispose();
+                this._currentReleaseNotes = undefined;
+            }));
+            this._currentReleaseNotes.webview.setHtml(html);
+        }
+        return true;
+    }
+    async loadReleaseNotes(version, useCurrentFile) {
+        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 {
+                if (useCurrentFile) {
+                    const file = this._codeEditorService.getActiveCodeEditor()?.getModel()?.getValue();
+                    text = file ? file.substring(file.indexOf('#')) : undefined;
+                }
+                else {
+                    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 (useCurrentFile) {
+            return fetchReleaseNotes();
+        }
+        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);
+    }
+    async onDidClickLink(uri) {
+        if (uri.scheme === Schemas.codeSetting) ;
+        else {
+            this.addGAParameters(uri, 'ReleaseNotes')
+                .then(updated => this._openerService.open(updated, { allowCommands: ['workbench.action.openSettings'] }))
+                .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, undefined, undefined, this._simpleSettingRenderer);
+        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}
+
+					/* codesetting */
+
+					code:has(.codesetting)+code {
+						display: none;
+					}
+
+					code:has(.codesetting) {
+						background-color: var(--vscode-textPreformat-background);
+						color: var(--vscode-textPreformat-foreground);
+						padding-left: 1px;
+						margin-right: 3px;
+						padding-right: 0px;
+					}
+
+					code:has(.codesetting):focus {
+						border: 1px solid var(--vscode-button-border, transparent);
+					}
+
+					.codesetting {
+						color: var(--vscode-textPreformat-foreground);
+						padding: 0px 1px 1px 0px;
+						font-size: 0px;
+						overflow: hidden;
+						text-overflow: ellipsis;
+						outline-offset: 2px !important;
+						box-sizing: border-box;
+						text-align: center;
+						cursor: pointer;
+						display: inline;
+						margin-right: 3px;
+					}
+					.codesetting svg {
+						font-size: 12px;
+						text-align: center;
+						cursor: pointer;
+						border: 1px solid var(--vscode-button-secondaryBorder, transparent);
+						outline: 1px solid transparent;
+						line-height: 9px;
+						margin-bottom: -5px;
+						padding-left: 0px;
+						padding-top: 2px;
+						padding-bottom: 2px;
+						padding-right: 2px;
+						display: inline-block;
+						text-decoration: none;
+						text-rendering: auto;
+						text-transform: none;
+						-webkit-font-smoothing: antialiased;
+						-moz-osx-font-smoothing: grayscale;
+						user-select: none;
+						-webkit-user-select: none;
+					}
+					.codesetting .setting-name {
+						font-size: 13px;
+						padding-left: 2px;
+						padding-right: 3px;
+						padding-top: 1px;
+						padding-bottom: 1px;
+						margin-left: -5px;
+						margin-top: -3px;
+					}
+					.codesetting:hover {
+						color: var(--vscode-textPreformat-foreground) !important;
+						text-decoration: none !important;
+					}
+					code:has(.codesetting):hover {
+						filter: brightness(140%);
+						text-decoration: none !important;
+					}
+					.codesetting:focus {
+						outline: 0 !important;
+						text-decoration: none !important;
+						color: var(--vscode-button-hoverForeground) !important;
+					}
+					.codesetting .separator {
+						width: 1px;
+						height: 14px;
+						margin-bottom: -3px;
+						display: inline-block;
+						background-color: var(--vscode-editor-background);
+						font-size: 12px;
+						margin-right: 8px;
+					}
+
+					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;
+						}
+					});
+
+					window.addEventListener('click', event => {
+						const href = event.target.href ?? event.target.parentElement.href ?? event.target.parentElement.parentElement?.href;
+						if (href && (href.startsWith('${Schemas.codeSetting}'))) {
+							vscode.postMessage({ type: 'clickSetting', value: { uri: href, x: event.clientX, y: event.clientY }});
+						}
+					});
+
+					window.addEventListener('keypress', event => {
+						if (event.keyCode === 13) {
+							if (event.target.children.length > 0 && event.target.children[0].href) {
+								const clientRect = event.target.getBoundingClientRect();
+								vscode.postMessage({ type: 'clickSetting', value: { uri: event.target.children[0].href, x: clientRect.right , y: clientRect.bottom }});
+							}
+						}
+					});
+
+					input.addEventListener('change', event => {
+						vscode.postMessage({ type: 'showReleaseNotes', value: input.checked }, '*');
+					});
+				</script>
+			</body>
+		</html>`;
+    }
+    onDidChangeConfiguration(e) {
+        if (e.affectsConfiguration('update.showReleaseNotes')) {
+            this.updateCheckboxWebview();
+        }
+    }
+    onDidChangeActiveWebviewEditor(input) {
+        if (input && input === this._currentReleaseNotes) {
+            this.updateCheckboxWebview();
+        }
+    }
+    updateCheckboxWebview() {
+        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, ICodeEditorService)),
+    ( __param(9, IWebviewWorkbenchService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, IProductService)),
+    ( __param(12, IInstantiationService))
+], ReleaseNotesManager));
+export { ReleaseNotesManager };