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

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

@@ -0,0 +1,65 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { SimpleFindWidget } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+
+let WebviewFindWidget = class WebviewFindWidget extends SimpleFindWidget {
+    async _getResultCount(dataChanged) {
+        return undefined;
+    }
+    constructor(_delegate, contextViewService, contextKeyService, keybindingService) {
+        super({
+            showCommonFindToggles: false,
+            checkImeCompletionState: _delegate.checkImeCompletionState,
+            enableSash: true,
+        }, contextViewService, contextKeyService, keybindingService);
+        this._delegate = _delegate;
+        this._findWidgetFocused = KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED.bindTo(contextKeyService);
+        this._register(_delegate.hasFindResult(hasResult => {
+            this.updateButtons(hasResult);
+            this.focusFindBox();
+        }));
+        this._register(_delegate.onDidStopFind(() => {
+            this.updateButtons(false);
+        }));
+    }
+    find(previous) {
+        const val = this.inputValue;
+        if (val) {
+            this._delegate.find(val, previous);
+        }
+    }
+    hide(animated = true) {
+        super.hide(animated);
+        this._delegate.stopFind(true);
+        this._delegate.focus();
+    }
+    _onInputChanged() {
+        const val = this.inputValue;
+        if (val) {
+            this._delegate.updateFind(val);
+        }
+        else {
+            this._delegate.stopFind(false);
+        }
+        return false;
+    }
+    _onFocusTrackerFocus() {
+        this._findWidgetFocused.set(true);
+    }
+    _onFocusTrackerBlur() {
+        this._findWidgetFocused.reset();
+    }
+    _onFindInputFocusTrackerFocus() { }
+    _onFindInputFocusTrackerBlur() { }
+    findFirst() { }
+};
+WebviewFindWidget = ( __decorate([
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IKeybindingService))
+], WebviewFindWidget));
+
+export { WebviewFindWidget };

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

@@ -0,0 +1,59 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { WebviewThemeDataProvider } from './themeing.js';
+import { WebviewElement } from './webviewElement.js';
+import { OverlayWebview } from './overlayWebview.js';
+
+let WebviewService = class WebviewService extends Disposable {
+    constructor(_instantiationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._webviews = ( new Set());
+        this._onDidChangeActiveWebview = this._register(( new Emitter()));
+        this.onDidChangeActiveWebview = this._onDidChangeActiveWebview.event;
+        this._webviewThemeDataProvider = this._instantiationService.createInstance(WebviewThemeDataProvider);
+    }
+    get activeWebview() { return this._activeWebview; }
+    _updateActiveWebview(value) {
+        if (value !== this._activeWebview) {
+            this._activeWebview = value;
+            this._onDidChangeActiveWebview.fire(value);
+        }
+    }
+    get webviews() {
+        return ( this._webviews.values());
+    }
+    createWebviewElement(initInfo) {
+        const webview = this._instantiationService.createInstance(WebviewElement, initInfo, this._webviewThemeDataProvider);
+        this.registerNewWebview(webview);
+        return webview;
+    }
+    createWebviewOverlay(initInfo) {
+        const webview = this._instantiationService.createInstance(OverlayWebview, initInfo);
+        this.registerNewWebview(webview);
+        return webview;
+    }
+    registerNewWebview(webview) {
+        this._webviews.add(webview);
+        webview.onDidFocus(() => {
+            this._updateActiveWebview(webview);
+        });
+        const onBlur = () => {
+            if (this._activeWebview === webview) {
+                this._updateActiveWebview(undefined);
+            }
+        };
+        webview.onDidBlur(onBlur);
+        webview.onDidDispose(() => {
+            onBlur();
+            this._webviews.delete(webview);
+        });
+    }
+};
+WebviewService = ( __decorate([
+    ( __param(0, IInstantiationService))
+], WebviewService));
+
+export { WebviewService };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewCommands.js

@@ -0,0 +1,143 @@
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview.service';
+import { WebviewEditor } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditor';
+import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+
+const webviewActiveContextKeyExpr = ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', WebviewEditor.ID)), ( EditorContextKeys.focus.toNegated() )));
+class ShowWebViewEditorFindWidgetAction extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.showFind'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.showFind',
+        "Show find"
+    )); }
+    constructor() {
+        super({
+            id: ShowWebViewEditorFindWidgetAction.ID,
+            title: ShowWebViewEditorFindWidgetAction.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED
+                )),
+                primary: 2048  | 36 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.showFind();
+    }
+}
+class HideWebViewEditorFindCommand extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.hideFind'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.hideFind',
+        "Stop find"
+    )); }
+    constructor() {
+        super({
+            id: HideWebViewEditorFindCommand.ID,
+            title: HideWebViewEditorFindCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE
+                )),
+                primary: 9 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.hideFind();
+    }
+}
+class WebViewEditorFindNextCommand extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.findNext'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.findNext',
+        'Find next'
+    )); }
+    constructor() {
+        super({
+            id: WebViewEditorFindNextCommand.ID,
+            title: WebViewEditorFindNextCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED
+                )),
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.runFindAction(false);
+    }
+}
+class WebViewEditorFindPreviousCommand extends Action2 {
+    static { this.ID = 'editor.action.webvieweditor.findPrevious'; }
+    static { this.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'editor.action.webvieweditor.findPrevious',
+        'Find previous'
+    )); }
+    constructor() {
+        super({
+            id: WebViewEditorFindPreviousCommand.ID,
+            title: WebViewEditorFindPreviousCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED
+                )),
+                primary: 1024  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.runFindAction(true);
+    }
+}
+class ReloadWebviewAction extends Action2 {
+    static { this.ID = 'workbench.action.webview.reloadWebviewAction'; }
+    static { this.LABEL = ( localize2WithPath(
+        'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
+        'refreshWebviewLabel',
+        "Reload Webviews"
+    )); }
+    constructor() {
+        super({
+            id: ReloadWebviewAction.ID,
+            title: ReloadWebviewAction.LABEL,
+            category: Categories.Developer,
+            menu: [{
+                    id: MenuId.CommandPalette
+                }]
+        });
+    }
+    async run(accessor) {
+        const webviewService = accessor.get(IWebviewService);
+        for (const webview of webviewService.webviews) {
+            webview.reload();
+        }
+    }
+}
+function getActiveWebviewEditor(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const activeEditor = editorService.activeEditor;
+    return activeEditor instanceof WebviewInput ? activeEditor.webview : undefined;
+}
+
+export { HideWebViewEditorFindCommand, ReloadWebviewAction, ShowWebViewEditorFindWidgetAction, WebViewEditorFindNextCommand, WebViewEditorFindPreviousCommand };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditorInputSerializer.js

@@ -0,0 +1,121 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service';
+
+let WebviewEditorInputSerializer = class WebviewEditorInputSerializer {
+    static { this.ID = WebviewInput.typeId; }
+    constructor(_webviewWorkbenchService) {
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+    }
+    canSerialize(input) {
+        return this._webviewWorkbenchService.shouldPersist(input);
+    }
+    serialize(input) {
+        if (!this.canSerialize(input)) {
+            return undefined;
+        }
+        const data = this.toJson(input);
+        try {
+            return JSON.stringify(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    deserialize(_instantiationService, serializedEditorInput) {
+        const data = this.fromJson(JSON.parse(serializedEditorInput));
+        return this._webviewWorkbenchService.openRevivedWebview({
+            webviewInitInfo: {
+                providedViewType: data.providedId,
+                origin: data.origin,
+                title: data.title,
+                options: data.webviewOptions,
+                contentOptions: data.contentOptions,
+                extension: data.extension,
+            },
+            viewType: data.viewType,
+            title: data.title,
+            iconPath: data.iconPath,
+            state: data.state,
+            group: data.group
+        });
+    }
+    fromJson(data) {
+        return {
+            ...data,
+            extension: reviveWebviewExtensionDescription(data.extensionId, data.extensionLocation),
+            iconPath: reviveIconPath(data.iconPath),
+            state: reviveState(data.state),
+            webviewOptions: restoreWebviewOptions(data.options),
+            contentOptions: restoreWebviewContentOptions(data.options),
+        };
+    }
+    toJson(input) {
+        return {
+            origin: input.webview.origin,
+            viewType: input.viewType,
+            providedId: input.providedId,
+            title: input.getName(),
+            options: { ...input.webview.options, ...input.webview.contentOptions },
+            extensionLocation: input.extension?.location,
+            extensionId: input.extension?.id.value,
+            state: input.webview.state,
+            iconPath: input.iconPath ? { light: input.iconPath.light, dark: input.iconPath.dark, } : undefined,
+            group: input.group
+        };
+    }
+};
+WebviewEditorInputSerializer = ( __decorate([
+    ( __param(0, IWebviewWorkbenchService))
+], WebviewEditorInputSerializer));
+function reviveWebviewExtensionDescription(extensionId, extensionLocation) {
+    if (!extensionId) {
+        return undefined;
+    }
+    const location = reviveUri(extensionLocation);
+    if (!location) {
+        return undefined;
+    }
+    return {
+        id: ( new ExtensionIdentifier(extensionId)),
+        location,
+    };
+}
+function reviveIconPath(data) {
+    if (!data) {
+        return undefined;
+    }
+    const light = reviveUri(data.light);
+    const dark = reviveUri(data.dark);
+    return light && dark ? { light, dark } : undefined;
+}
+function reviveUri(data) {
+    if (!data) {
+        return undefined;
+    }
+    try {
+        if (typeof data === 'string') {
+            return ( URI.parse(data));
+        }
+        return ( URI.from(data));
+    }
+    catch {
+        return undefined;
+    }
+}
+function reviveState(state) {
+    return typeof state === 'string' ? state : undefined;
+}
+function restoreWebviewOptions(options) {
+    return options;
+}
+function restoreWebviewContentOptions(options) {
+    return {
+        ...options,
+        localResourceRoots: options.localResourceRoots?.map(uri => reviveUri(uri)),
+    };
+}
+
+export { WebviewEditorInputSerializer, restoreWebviewContentOptions, restoreWebviewOptions, reviveWebviewExtensionDescription };

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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { ShowWebViewEditorFindWidgetAction, HideWebViewEditorFindCommand, WebViewEditorFindNextCommand, WebViewEditorFindPreviousCommand, ReloadWebviewAction } from './webviewCommands.js';
+import { WebviewEditor } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditor';
+import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { WebviewEditorInputSerializer } from './webviewEditorInputSerializer.js';
+import 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+
+(( Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, ( localizeWithPath(
+    'vs/workbench/contrib/webviewPanel/browser/webviewPanel.contribution',
+    'webview.editor.label',
+    "webview editor"
+))), [( new SyncDescriptor(WebviewInput))]);
+let WebviewPanelContribution = class WebviewPanelContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.webviewPanel'; }
+    constructor(editorService, editorGroupService) {
+        super();
+        this.editorGroupService = editorGroupService;
+        this._register(editorService.onWillOpenEditor(e => {
+            const group = editorGroupService.getGroup(e.groupId);
+            if (group) {
+                this.onEditorOpening(e.editor, group);
+            }
+        }));
+    }
+    onEditorOpening(editor, group) {
+        if (!(editor instanceof WebviewInput) || editor.typeId !== WebviewInput.typeId) {
+            return;
+        }
+        if (group.contains(editor)) {
+            return;
+        }
+        let previousGroup;
+        const groups = this.editorGroupService.groups;
+        for (const group of groups) {
+            if (group.contains(editor)) {
+                previousGroup = group;
+                break;
+            }
+        }
+        if (!previousGroup) {
+            return;
+        }
+        previousGroup.closeEditor(editor);
+    }
+};
+WebviewPanelContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IEditorGroupsService))
+], WebviewPanelContribution));
+registerWorkbenchContribution2(WebviewPanelContribution.ID, WebviewPanelContribution, 1 );
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(WebviewEditorInputSerializer.ID, WebviewEditorInputSerializer);
+registerAction2(ShowWebViewEditorFindWidgetAction);
+registerAction2(HideWebViewEditorFindCommand);
+registerAction2(WebViewEditorFindNextCommand);
+registerAction2(WebViewEditorFindPreviousCommand);
+registerAction2(ReloadWebviewAction);