@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/contrib/webview/browser/overlayWebview.js

@@ -0,0 +1,314 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { getWindowById } from 'vscode/vscode/vs/base/browser/dom';
+import { FastDomNode } from 'vscode/vscode/vs/base/browser/fastDomNode';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview.service';
+
+let OverlayWebview = class OverlayWebview extends Disposable {
+    get window() { return getWindowById(this._windowId, true).window; }
+    constructor(initInfo, _layoutService, _webviewService, _baseContextKeyService) {
+        super();
+        this._layoutService = _layoutService;
+        this._webviewService = _webviewService;
+        this._baseContextKeyService = _baseContextKeyService;
+        this._isFirstLoad = true;
+        this._firstLoadPendingMessages = ( new Set());
+        this._webview = this._register(( new MutableDisposable()));
+        this._webviewEvents = this._register(( new DisposableStore()));
+        this._html = '';
+        this._initialScrollProgress = 0;
+        this._state = undefined;
+        this._owner = undefined;
+        this._windowId = undefined;
+        this._scopedContextKeyService = this._register(( new MutableDisposable()));
+        this._shouldShowFindWidgetOnRestore = false;
+        this._isDisposed = false;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( new Emitter()));
+        this.onDidBlur = this._onDidBlur.event;
+        this._onDidClickLink = this._register(( new Emitter()));
+        this.onDidClickLink = this._onDidClickLink.event;
+        this._onDidReload = this._register(( new Emitter()));
+        this.onDidReload = this._onDidReload.event;
+        this._onDidScroll = this._register(( new Emitter()));
+        this.onDidScroll = this._onDidScroll.event;
+        this._onDidUpdateState = this._register(( new Emitter()));
+        this.onDidUpdateState = this._onDidUpdateState.event;
+        this._onMessage = this._register(( new Emitter()));
+        this.onMessage = this._onMessage.event;
+        this._onMissingCsp = this._register(( new Emitter()));
+        this.onMissingCsp = this._onMissingCsp.event;
+        this._onDidWheel = this._register(( new Emitter()));
+        this.onDidWheel = this._onDidWheel.event;
+        this._onFatalError = this._register(( new Emitter()));
+        this.onFatalError = this._onFatalError.event;
+        this.providedViewType = initInfo.providedViewType;
+        this.origin = initInfo.origin ?? generateUuid();
+        this._title = initInfo.title;
+        this._extension = initInfo.extension;
+        this._options = initInfo.options;
+        this._contentOptions = initInfo.contentOptions;
+    }
+    get isFocused() {
+        return !!this._webview.value?.isFocused;
+    }
+    dispose() {
+        this._isDisposed = true;
+        this._container?.domNode.remove();
+        this._container = undefined;
+        for (const msg of this._firstLoadPendingMessages) {
+            msg.resolve(false);
+        }
+        this._firstLoadPendingMessages.clear();
+        this._onDidDispose.fire();
+        super.dispose();
+    }
+    get container() {
+        if (this._isDisposed) {
+            throw new Error(`OverlayWebview has been disposed`);
+        }
+        if (!this._container) {
+            const node = document.createElement('div');
+            node.style.position = 'absolute';
+            node.style.overflow = 'hidden';
+            this._container = ( new FastDomNode(node));
+            this._container.setVisibility('hidden');
+            this._layoutService.getContainer(this.window).appendChild(node);
+        }
+        return this._container.domNode;
+    }
+    claim(owner, targetWindow, scopedContextKeyService) {
+        if (this._isDisposed) {
+            return;
+        }
+        const oldOwner = this._owner;
+        if (this._windowId !== targetWindow.vscodeWindowId) {
+            this.release(oldOwner);
+            this._webview.clear();
+            this._webviewEvents.clear();
+            this._container?.domNode.remove();
+            this._container = undefined;
+        }
+        this._owner = owner;
+        this._windowId = targetWindow.vscodeWindowId;
+        this._show(targetWindow);
+        if (oldOwner !== owner) {
+            const contextKeyService = (scopedContextKeyService || this._baseContextKeyService);
+            this._scopedContextKeyService.clear();
+            this._scopedContextKeyService.value = contextKeyService.createScoped(this.container);
+            const wasFindVisible = this._findWidgetVisible?.get();
+            this._findWidgetVisible?.reset();
+            this._findWidgetVisible = KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE.bindTo(contextKeyService);
+            this._findWidgetVisible.set(!!wasFindVisible);
+            this._findWidgetEnabled?.reset();
+            this._findWidgetEnabled = KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED.bindTo(contextKeyService);
+            this._findWidgetEnabled.set(!!this.options.enableFindWidget);
+            this._webview.value?.setContextKeyService(this._scopedContextKeyService.value);
+        }
+    }
+    release(owner) {
+        if (this._owner !== owner) {
+            return;
+        }
+        this._scopedContextKeyService.clear();
+        this._owner = undefined;
+        if (this._container) {
+            this._container.setVisibility('hidden');
+        }
+        if (this._options.retainContextWhenHidden) {
+            this._shouldShowFindWidgetOnRestore = !!this._findWidgetVisible?.get();
+            this.hideFind(false);
+        }
+        else {
+            this._webview.clear();
+            this._webviewEvents.clear();
+        }
+    }
+    layoutWebviewOverElement(element, dimension, clippingContainer) {
+        if (!this._container || !this._container.domNode.parentElement) {
+            return;
+        }
+        const whenContainerStylesLoaded = this._layoutService.whenContainerStylesLoaded(this.window);
+        if (whenContainerStylesLoaded) {
+            whenContainerStylesLoaded.then(() => this.doLayoutWebviewOverElement(element, dimension, clippingContainer));
+        }
+        else {
+            this.doLayoutWebviewOverElement(element, dimension, clippingContainer);
+        }
+    }
+    doLayoutWebviewOverElement(element, dimension, clippingContainer) {
+        if (!this._container || !this._container.domNode.parentElement) {
+            return;
+        }
+        const frameRect = element.getBoundingClientRect();
+        const containerRect = this._container.domNode.parentElement.getBoundingClientRect();
+        const parentBorderTop = (containerRect.height - this._container.domNode.parentElement.clientHeight) / 2.0;
+        const parentBorderLeft = (containerRect.width - this._container.domNode.parentElement.clientWidth) / 2.0;
+        this._container.setTop(frameRect.top - containerRect.top - parentBorderTop);
+        this._container.setLeft(frameRect.left - containerRect.left - parentBorderLeft);
+        this._container.setWidth(dimension ? dimension.width : frameRect.width);
+        this._container.setHeight(dimension ? dimension.height : frameRect.height);
+        if (clippingContainer) {
+            const { top, left, right, bottom } = computeClippingRect(frameRect, clippingContainer);
+            this._container.domNode.style.clipPath = `polygon(${left}px ${top}px, ${right}px ${top}px, ${right}px ${bottom}px, ${left}px ${bottom}px)`;
+        }
+    }
+    _show(targetWindow) {
+        if (this._isDisposed) {
+            throw new Error('OverlayWebview is disposed');
+        }
+        if (!this._webview.value) {
+            const webview = this._webviewService.createWebviewElement({
+                providedViewType: this.providedViewType,
+                origin: this.origin,
+                title: this._title,
+                options: this._options,
+                contentOptions: this._contentOptions,
+                extension: this.extension,
+            });
+            this._webview.value = webview;
+            webview.state = this._state;
+            if (this._scopedContextKeyService.value) {
+                this._webview.value.setContextKeyService(this._scopedContextKeyService.value);
+            }
+            if (this._html) {
+                webview.setHtml(this._html);
+            }
+            if (this._options.tryRestoreScrollPosition) {
+                webview.initialScrollProgress = this._initialScrollProgress;
+            }
+            this._findWidgetEnabled?.set(!!this.options.enableFindWidget);
+            webview.mountTo(this.container, targetWindow);
+            this._webviewEvents.clear();
+            this._webviewEvents.add(webview.onDidFocus(() => { this._onDidFocus.fire(); }));
+            this._webviewEvents.add(webview.onDidBlur(() => { this._onDidBlur.fire(); }));
+            this._webviewEvents.add(webview.onDidClickLink(x => { this._onDidClickLink.fire(x); }));
+            this._webviewEvents.add(webview.onMessage(x => { this._onMessage.fire(x); }));
+            this._webviewEvents.add(webview.onMissingCsp(x => { this._onMissingCsp.fire(x); }));
+            this._webviewEvents.add(webview.onDidWheel(x => { this._onDidWheel.fire(x); }));
+            this._webviewEvents.add(webview.onDidReload(() => { this._onDidReload.fire(); }));
+            this._webviewEvents.add(webview.onFatalError(x => { this._onFatalError.fire(x); }));
+            this._webviewEvents.add(webview.onDidScroll(x => {
+                this._initialScrollProgress = x.scrollYPercentage;
+                this._onDidScroll.fire(x);
+            }));
+            this._webviewEvents.add(webview.onDidUpdateState(state => {
+                this._state = state;
+                this._onDidUpdateState.fire(state);
+            }));
+            if (this._isFirstLoad) {
+                this._firstLoadPendingMessages.forEach(async (msg) => {
+                    msg.resolve(await webview.postMessage(msg.message, msg.transfer));
+                });
+            }
+            this._isFirstLoad = false;
+            this._firstLoadPendingMessages.clear();
+        }
+        if (this.options.retainContextWhenHidden && this._shouldShowFindWidgetOnRestore) {
+            this.showFind(false);
+            this._shouldShowFindWidgetOnRestore = false;
+        }
+        this._container?.setVisibility('visible');
+    }
+    setHtml(html) {
+        this._html = html;
+        this._withWebview(webview => webview.setHtml(html));
+    }
+    setTitle(title) {
+        this._title = title;
+        this._withWebview(webview => webview.setTitle(title));
+    }
+    get initialScrollProgress() { return this._initialScrollProgress; }
+    set initialScrollProgress(value) {
+        this._initialScrollProgress = value;
+        this._withWebview(webview => webview.initialScrollProgress = value);
+    }
+    get state() { return this._state; }
+    set state(value) {
+        this._state = value;
+        this._withWebview(webview => webview.state = value);
+    }
+    get extension() { return this._extension; }
+    set extension(value) {
+        this._extension = value;
+        this._withWebview(webview => webview.extension = value);
+    }
+    get options() { return this._options; }
+    set options(value) { this._options = { customClasses: this._options.customClasses, ...value }; }
+    get contentOptions() { return this._contentOptions; }
+    set contentOptions(value) {
+        this._contentOptions = value;
+        this._withWebview(webview => webview.contentOptions = value);
+    }
+    set localResourcesRoot(resources) {
+        this._withWebview(webview => webview.localResourcesRoot = resources);
+    }
+    async postMessage(message, transfer) {
+        if (this._webview.value) {
+            return this._webview.value.postMessage(message, transfer);
+        }
+        if (this._isFirstLoad) {
+            let resolve;
+            const p = ( new Promise(r => resolve = r));
+            this._firstLoadPendingMessages.add({ message, transfer, resolve: resolve });
+            return p;
+        }
+        return false;
+    }
+    focus() { this._webview.value?.focus(); }
+    reload() { this._webview.value?.reload(); }
+    selectAll() { this._webview.value?.selectAll(); }
+    copy() { this._webview.value?.copy(); }
+    paste() { this._webview.value?.paste(); }
+    cut() { this._webview.value?.cut(); }
+    undo() { this._webview.value?.undo(); }
+    redo() { this._webview.value?.redo(); }
+    showFind(animated = true) {
+        if (this._webview.value) {
+            this._webview.value.showFind(animated);
+            this._findWidgetVisible?.set(true);
+        }
+    }
+    hideFind(animated = true) {
+        this._findWidgetVisible?.reset();
+        this._webview.value?.hideFind(animated);
+    }
+    runFindAction(previous) { this._webview.value?.runFindAction(previous); }
+    _withWebview(f) {
+        if (this._webview.value) {
+            f(this._webview.value);
+        }
+    }
+    windowDidDragStart() {
+        this._webview.value?.windowDidDragStart();
+    }
+    windowDidDragEnd() {
+        this._webview.value?.windowDidDragEnd();
+    }
+    setContextKeyService(contextKeyService) {
+        this._webview.value?.setContextKeyService(contextKeyService);
+    }
+};
+OverlayWebview = ( __decorate([
+    ( __param(1, IWorkbenchLayoutService)),
+    ( __param(2, IWebviewService)),
+    ( __param(3, IContextKeyService))
+], OverlayWebview));
+function computeClippingRect(frameRect, clipper) {
+    const rootRect = clipper.getBoundingClientRect();
+    const top = Math.max(rootRect.top - frameRect.top, 0);
+    const right = Math.max(frameRect.width - (frameRect.right - rootRect.right), 0);
+    const bottom = Math.max(frameRect.height - (frameRect.bottom - rootRect.bottom), 0);
+    const left = Math.max(rootRect.left - frameRect.left, 0);
+    return { top, right, bottom, left };
+}
+
+export { OverlayWebview };

package/vscode/src/vs/workbench/contrib/webview/browser/resourceLoading.js

@@ -0,0 +1,96 @@
+import { isUNC } from 'vscode/vscode/vs/base/common/extpath';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { normalize, sep } from 'vscode/vscode/vs/base/common/path';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { FileOperationError } from 'vscode/vscode/vs/platform/files/common/files';
+import { getWebviewContentMimeType } from '../../../../platform/webview/common/mimeTypes.js';
+
+var WebviewResourceResponse;
+( (function(WebviewResourceResponse) {
+    let Type;
+    ( (function(Type) {
+        Type[Type["Success"] = 0] = "Success";
+        Type[Type["Failed"] = 1] = "Failed";
+        Type[Type["AccessDenied"] = 2] = "AccessDenied";
+        Type[Type["NotModified"] = 3] = "NotModified";
+    })(Type = WebviewResourceResponse.Type || (WebviewResourceResponse.Type = {})));
+    class StreamSuccess {
+        constructor(stream, etag, mtime, mimeType) {
+            this.stream = stream;
+            this.etag = etag;
+            this.mtime = mtime;
+            this.mimeType = mimeType;
+            this.type = Type.Success;
+        }
+    }
+    WebviewResourceResponse.StreamSuccess = StreamSuccess;
+    WebviewResourceResponse.Failed = { type: Type.Failed };
+    WebviewResourceResponse.AccessDenied = { type: Type.AccessDenied };
+    class NotModified {
+        constructor(mimeType, mtime) {
+            this.mimeType = mimeType;
+            this.mtime = mtime;
+            this.type = Type.NotModified;
+        }
+    }
+    WebviewResourceResponse.NotModified = NotModified;
+})(WebviewResourceResponse || (WebviewResourceResponse = {})));
+async function loadLocalResource(requestUri, options, fileService, logService, token) {
+    logService.debug(`loadLocalResource - begin. requestUri=${requestUri}`);
+    const resourceToLoad = getResourceToLoad(requestUri, options.roots);
+    logService.debug(`loadLocalResource - found resource to load. requestUri=${requestUri}, resourceToLoad=${resourceToLoad}`);
+    if (!resourceToLoad) {
+        return WebviewResourceResponse.AccessDenied;
+    }
+    const mime = getWebviewContentMimeType(requestUri);
+    try {
+        const result = await fileService.readFileStream(resourceToLoad, { etag: options.ifNoneMatch }, token);
+        return new WebviewResourceResponse.StreamSuccess(result.value, result.etag, result.mtime, mime);
+    }
+    catch (err) {
+        if (err instanceof FileOperationError) {
+            const result = err.fileOperationResult;
+            if (result === 2 ) {
+                return new WebviewResourceResponse.NotModified(mime, err.options?.mtime);
+            }
+        }
+        logService.debug(`loadLocalResource - Error using fileReader. requestUri=${requestUri}`);
+        console.log(err);
+        return WebviewResourceResponse.Failed;
+    }
+}
+function getResourceToLoad(requestUri, roots) {
+    for (const root of roots) {
+        if (containsResource(root, requestUri)) {
+            return normalizeResourcePath(requestUri);
+        }
+    }
+    return undefined;
+}
+function containsResource(root, resource) {
+    if (root.scheme !== resource.scheme) {
+        return false;
+    }
+    let resourceFsPath = normalize(resource.fsPath);
+    let rootPath = normalize(root.fsPath + (root.fsPath.endsWith(sep) ? '' : sep));
+    if (isUNC(root.fsPath) && isUNC(resource.fsPath)) {
+        rootPath = rootPath.toLowerCase();
+        resourceFsPath = resourceFsPath.toLowerCase();
+    }
+    return resourceFsPath.startsWith(rootPath);
+}
+function normalizeResourcePath(resource) {
+    if (resource.scheme === Schemas.vscodeRemote) {
+        return ( URI.from({
+            scheme: Schemas.vscodeRemote,
+            authority: resource.authority,
+            path: '/vscode-resource',
+            query: JSON.stringify({
+                requestResourcePath: resource.path
+            })
+        }));
+    }
+    return resource;
+}
+
+export { WebviewResourceResponse, loadLocalResource };

package/vscode/src/vs/workbench/contrib/webview/browser/themeing.js

@@ -0,0 +1,98 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { DEFAULT_FONT_FAMILY } from 'vscode/vscode/vs/base/browser/fonts';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { EDITOR_FONT_DEFAULTS } from 'vscode/vscode/vs/editor/common/config/editorOptions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { getColorRegistry } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { ColorScheme } from 'vscode/vscode/vs/platform/theme/common/theme';
+import { IWorkbenchThemeService } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService.service';
+
+let WebviewThemeDataProvider = class WebviewThemeDataProvider extends Disposable {
+    constructor(_themeService, _configurationService) {
+        super();
+        this._themeService = _themeService;
+        this._configurationService = _configurationService;
+        this._cachedWebViewThemeData = undefined;
+        this._onThemeDataChanged = this._register(( new Emitter()));
+        this.onThemeDataChanged = this._onThemeDataChanged.event;
+        this._register(this._themeService.onDidColorThemeChange(() => {
+            this._reset();
+        }));
+        const webviewConfigurationKeys = ['editor.fontFamily', 'editor.fontWeight', 'editor.fontSize'];
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (( webviewConfigurationKeys.some(key => e.affectsConfiguration(key)))) {
+                this._reset();
+            }
+        }));
+    }
+    getTheme() {
+        return this._themeService.getColorTheme();
+    }
+    getWebviewThemeData() {
+        if (!this._cachedWebViewThemeData) {
+            const configuration = this._configurationService.getValue('editor');
+            const editorFontFamily = configuration.fontFamily || EDITOR_FONT_DEFAULTS.fontFamily;
+            const editorFontWeight = configuration.fontWeight || EDITOR_FONT_DEFAULTS.fontWeight;
+            const editorFontSize = configuration.fontSize || EDITOR_FONT_DEFAULTS.fontSize;
+            const theme = this._themeService.getColorTheme();
+            const exportedColors = getColorRegistry().getColors().reduce((colors, entry) => {
+                const color = theme.getColor(entry.id);
+                if (color) {
+                    colors['vscode-' + entry.id.replace('.', '-')] = ( color.toString());
+                }
+                return colors;
+            }, {});
+            const styles = {
+                'vscode-font-family': DEFAULT_FONT_FAMILY,
+                'vscode-font-weight': 'normal',
+                'vscode-font-size': '13px',
+                'vscode-editor-font-family': editorFontFamily,
+                'vscode-editor-font-weight': editorFontWeight,
+                'vscode-editor-font-size': editorFontSize + 'px',
+                ...exportedColors
+            };
+            const activeTheme = ApiThemeClassName.fromTheme(theme);
+            this._cachedWebViewThemeData = { styles, activeTheme, themeLabel: theme.label, themeId: theme.settingsId };
+        }
+        return this._cachedWebViewThemeData;
+    }
+    _reset() {
+        this._cachedWebViewThemeData = undefined;
+        this._onThemeDataChanged.fire();
+    }
+};
+WebviewThemeDataProvider = ( __decorate([
+    ( __param(0, IWorkbenchThemeService)),
+    ( __param(1, IConfigurationService))
+], WebviewThemeDataProvider));
+var ApiThemeClassName;
+( (function(ApiThemeClassName) {
+    ApiThemeClassName["light"] = "vscode-light";
+    ApiThemeClassName["dark"] = "vscode-dark";
+    ApiThemeClassName["highContrast"] = "vscode-high-contrast";
+    ApiThemeClassName["highContrastLight"] = "vscode-high-contrast-light";
+})(ApiThemeClassName || (ApiThemeClassName = {})));
+( (function(ApiThemeClassName) {
+    function fromTheme(theme) {
+        switch (theme.type) {
+            case ColorScheme.LIGHT: return ApiThemeClassName.light;
+            case ColorScheme.DARK: return ApiThemeClassName.dark;
+            case ColorScheme.HIGH_CONTRAST_DARK: return ApiThemeClassName.highContrast;
+            case ColorScheme.HIGH_CONTRAST_LIGHT: return ApiThemeClassName.highContrastLight;
+        }
+    }
+    ApiThemeClassName.fromTheme = fromTheme;
+})(ApiThemeClassName || (ApiThemeClassName = {})));
+
+export { WebviewThemeDataProvider };