@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

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

@@ -0,0 +1,24 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { DebugService } from './vscode/src/vs/workbench/contrib/debug/browser/debugService.js';
+import { LanguageFeaturesService } from './vscode/src/vs/editor/common/services/languageFeaturesService.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ConfigurationResolverService } from './vscode/src/vs/workbench/services/configurationResolver/browser/configurationResolverService.js';
+import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver';
+import getServiceOverride$1 from 'vscode/service-override/layout';
+import './vscode/src/vs/workbench/contrib/debug/browser/debug.contribution.js';
+
+const original = DebugService.prototype['showError'];
+DebugService.prototype['showError'] = function (message, errorActions) {
+    return original.call(this, message, errorActions, false);
+};
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( ILanguageFeaturesService.toString())]: new SyncDescriptor(LanguageFeaturesService, [], true),
+        [( IDebugService.toString())]: new SyncDescriptor(DebugService, [], true),
+        [( IConfigurationResolverService.toString())]: new SyncDescriptor(ConfigurationResolverService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

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

@@ -1 +1 @@
-export { default } from 'vscode/service-override/debug'
+export { default } from './debug.js';

package/index.js

@@ -1 +1 @@
-export { default } from 'vscode/service-override/debug'
+export { default } from './debug.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

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-debug-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.1",
     "monaco-editor": "0.43.0"
   }
 }

package/vscode/src/vs/editor/common/services/languageFeaturesService.js

@@ -0,0 +1,44 @@
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+
+class LanguageFeaturesService {
+    constructor() {
+        this.referenceProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.renameProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.codeActionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.definitionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.typeDefinitionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.declarationProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.implementationProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentSymbolProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlayHintsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.colorProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.codeLensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentRangeFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.onTypeFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.signatureHelpProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.hoverProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentHighlightProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.selectionRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.foldingRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.linkProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlineCompletionsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.completionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.linkedEditingRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlineValuesProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.evaluatableExpressionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentRangeSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentOnDropEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentPasteEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.mappedEditsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+    }
+    setNotebookTypeResolver(resolver) {
+        this._notebookTypeResolver = resolver;
+    }
+    _score(uri) {
+        return this._notebookTypeResolver?.(uri);
+    }
+}
+
+export { LanguageFeaturesService };

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -0,0 +1,200 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { DisposableStore, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
+import { ReplEvaluationResult } from '../common/replModel.js';
+
+const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
+const booleanRegex = /^(true|false)$/i;
+const stringRegex = /^(['"]).*\1$/;
+const $ = dom.$;
+function renderViewTree(container) {
+    const treeContainer = $('.');
+    treeContainer.classList.add('debug-view-content');
+    container.appendChild(treeContainer);
+    return treeContainer;
+}
+function renderExpressionValue(expressionOrValue, container, options) {
+    let value = typeof expressionOrValue === 'string' ? expressionOrValue : expressionOrValue.value;
+    container.className = 'value';
+    if (value === null || ((expressionOrValue instanceof Expression || expressionOrValue instanceof Variable || expressionOrValue instanceof ReplEvaluationResult) && !expressionOrValue.available)) {
+        container.classList.add('unavailable');
+        if (value !== Expression.DEFAULT_VALUE) {
+            container.classList.add('error');
+        }
+    }
+    else {
+        if ((expressionOrValue instanceof ExpressionContainer) && options.showChanged && expressionOrValue.valueChanged && value !== Expression.DEFAULT_VALUE) {
+            container.className = 'value changed';
+            expressionOrValue.valueChanged = false;
+        }
+        if (options.colorize && typeof expressionOrValue !== 'string') {
+            if (expressionOrValue.type === 'number' || expressionOrValue.type === 'boolean' || expressionOrValue.type === 'string') {
+                container.classList.add(expressionOrValue.type);
+            }
+            else if (!isNaN(+value)) {
+                container.classList.add('number');
+            }
+            else if (booleanRegex.test(value)) {
+                container.classList.add('boolean');
+            }
+            else if (stringRegex.test(value)) {
+                container.classList.add('string');
+            }
+        }
+    }
+    if (options.maxValueLength && value && value.length > options.maxValueLength) {
+        value = value.substring(0, options.maxValueLength) + '...';
+    }
+    if (!value) {
+        value = '';
+    }
+    if (options.linkDetector) {
+        container.textContent = '';
+        const session = (expressionOrValue instanceof ExpressionContainer) ? expressionOrValue.getSession() : undefined;
+        container.appendChild(options.linkDetector.linkify(value, false, session ? session.root : undefined, true));
+    }
+    else {
+        container.textContent = value;
+    }
+    if (options.showHover) {
+        container.title = value || '';
+    }
+}
+function renderVariable(variable, data, showChanged, highlights, linkDetector) {
+    if (variable.available) {
+        let text = variable.name;
+        if (variable.value && typeof variable.name === 'string') {
+            text += ':';
+        }
+        data.label.set(text, highlights, variable.type ? variable.type : variable.name);
+        data.name.classList.toggle('virtual', variable.presentationHint?.kind === 'virtual');
+        data.name.classList.toggle('internal', variable.presentationHint?.visibility === 'internal');
+    }
+    else if (variable.value && typeof variable.name === 'string' && variable.name) {
+        data.label.set(':');
+    }
+    data.expression.classList.toggle('lazy', !!variable.presentationHint?.lazy);
+    renderExpressionValue(variable, data.value, {
+        showChanged,
+        maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
+        showHover: true,
+        colorize: true,
+        linkDetector
+    });
+}
+let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
+    constructor(debugService, contextViewService) {
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+    }
+    renderTemplate(container) {
+        const expression = dom.append(container, $('.expression'));
+        const name = dom.append(expression, $('span.name'));
+        const lazyButton = dom.append(expression, $('span.lazy-button'));
+        lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
+        lazyButton.title = ( localize('debug.lazyButton.tooltip', "Click to expand"));
+        const value = dom.append(expression, $('span.value'));
+        const label = ( new HighlightedLabel(name));
+        const inputBoxContainer = dom.append(expression, $('.inputBoxContainer'));
+        const templateDisposable = ( new DisposableStore());
+        let actionBar;
+        if (this.renderActionBar) {
+            dom.append(expression, $('.span.actionbar-spacer'));
+            actionBar = templateDisposable.add(( new ActionBar(expression)));
+        }
+        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: [], templateDisposable, lazyButton, currentElement: undefined };
+        templateDisposable.add(dom.addDisposableListener(lazyButton, dom.EventType.CLICK, () => {
+            if (template.currentElement) {
+                this.debugService.getViewModel().evaluateLazyExpression(template.currentElement);
+            }
+        }));
+        return template;
+    }
+    renderExpressionElement(element, node, data) {
+        data.currentElement = element;
+        this.renderExpression(node.element, data, createMatches(node.filterData));
+        if (data.actionBar) {
+            this.renderActionBar(data.actionBar, element, data);
+        }
+        const selectedExpression = this.debugService.getViewModel().getSelectedExpression();
+        if (element === selectedExpression?.expression || (element instanceof Variable && element.errorMessage)) {
+            const options = this.getInputBoxOptions(element, !!selectedExpression?.settingWatch);
+            if (options) {
+                data.elementDisposable.push(this.renderInputBox(data.name, data.value, data.inputBoxContainer, options));
+            }
+        }
+    }
+    renderInputBox(nameElement, valueElement, inputBoxContainer, options) {
+        nameElement.style.display = 'none';
+        valueElement.style.display = 'none';
+        inputBoxContainer.style.display = 'initial';
+        dom.clearNode(inputBoxContainer);
+        const inputBox = ( new InputBox(
+            inputBoxContainer,
+            this.contextViewService,
+            { ...options, inputBoxStyles: defaultInputBoxStyles }
+        ));
+        inputBox.value = options.initialValue;
+        inputBox.focus();
+        inputBox.select();
+        const done = once((success, finishEditing) => {
+            nameElement.style.display = '';
+            valueElement.style.display = '';
+            inputBoxContainer.style.display = 'none';
+            const value = inputBox.value;
+            dispose(toDispose);
+            if (finishEditing) {
+                this.debugService.getViewModel().setSelectedExpression(undefined, false);
+                options.onFinish(value, success);
+            }
+        });
+        const toDispose = [
+            inputBox,
+            dom.addStandardDisposableListener(inputBox.inputElement, dom.EventType.KEY_DOWN, (e) => {
+                const isEscape = e.equals(9 );
+                const isEnter = e.equals(3 );
+                if (isEscape || isEnter) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    done(isEnter, true);
+                }
+            }),
+            dom.addDisposableListener(inputBox.inputElement, dom.EventType.BLUR, () => {
+                done(true, true);
+            }),
+            dom.addDisposableListener(inputBox.inputElement, dom.EventType.CLICK, e => {
+                e.preventDefault();
+                e.stopPropagation();
+            })
+        ];
+        return toDisposable(() => {
+            done(false, false);
+        });
+    }
+    disposeElement(node, index, templateData) {
+        dispose(templateData.elementDisposable);
+        templateData.elementDisposable = [];
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.elementDisposable);
+        templateData.templateDisposable.dispose();
+    }
+};
+AbstractExpressionsRenderer = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IContextViewService))
+], AbstractExpressionsRenderer));
+
+export { AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree };