@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.6

package/dist/vscode/vs/workbench/contrib/debug/browser/watchExpressionsView.js

@@ -1,411 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { WATCH_VIEW_ID, CONTEXT_WATCH_EXPRESSIONS_EXIST, IDebugService, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_ITEM_TYPE, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_CAN_VIEW_MEMORY } from '../common/debug.js';
-import { Expression, Variable } from '../common/debugModel.js';
-import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { renderViewTree, AbstractExpressionsRenderer, renderExpressionValue } from './baseDebugView.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ViewAction, ViewPane } from '../../../browser/parts/views/viewPane.js';
-import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { ElementsDragAndDropData } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
-import { VariablesRenderer } from './variablesView.js';
-import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IViewDescriptorService } from '../../../common/views.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { watchExpressionsAdd, watchExpressionsRemoveAll } from './debugIcons.js';
-import { registerAction2, MenuId, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { LinkDetector } from './linkDetector.js';
-const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
-let ignoreViewUpdates = false;
-let useCachedEvaluation = false;
-let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
-    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, telemetryService, menuService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.debugService = debugService;
-        this.needsRefresh = false;
-        this.menu = menuService.createMenu(MenuId.DebugWatchContext, contextKeyService);
-        this._register(this.menu);
-        this.watchExpressionsUpdatedScheduler = ( new RunOnceScheduler(() => {
-            this.needsRefresh = false;
-            this.tree.updateChildren();
-        }, 50));
-        this.watchExpressionsExist = CONTEXT_WATCH_EXPRESSIONS_EXIST.bindTo(contextKeyService);
-        this.variableReadonly = CONTEXT_VARIABLE_IS_READONLY.bindTo(contextKeyService);
-        this.watchExpressionsExist.set(this.debugService.getModel().getWatchExpressions().length > 0);
-        this.watchItemType = CONTEXT_WATCH_ITEM_TYPE.bindTo(contextKeyService);
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        this.element.classList.add('debug-pane');
-        container.classList.add('debug-watch');
-        const treeContainer = renderViewTree(container);
-        const expressionsRenderer = this.instantiationService.createInstance(WatchExpressionsRenderer);
-        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( new WatchExpressionsDelegate()), [expressionsRenderer, this.instantiationService.createInstance(VariablesRenderer, linkeDetector)], ( new WatchExpressionsDataSource()), {
-            accessibilityProvider: ( new WatchExpressionsAccessibilityProvider()),
-            identityProvider: { getId: (element) => element.getId() },
-            keyboardNavigationLabelProvider: {
-                getKeyboardNavigationLabel: (e) => {
-                    if (e === this.debugService.getViewModel().getSelectedExpression()?.expression) {
-                        return undefined;
-                    }
-                    return e.name;
-                }
-            },
-            dnd: ( new WatchExpressionsDragAndDrop(this.debugService)),
-            overrideStyles: {
-                listBackground: this.getBackgroundColor()
-            }
-        });
-        this.tree.setInput(this.debugService);
-        CONTEXT_WATCH_EXPRESSIONS_FOCUSED.bindTo(this.tree.contextKeyService);
-        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
-        this._register(this.tree.onMouseDblClick(e => this.onMouseDblClick(e)));
-        this._register(this.debugService.getModel().onDidChangeWatchExpressions(async (we) => {
-            this.watchExpressionsExist.set(this.debugService.getModel().getWatchExpressions().length > 0);
-            if (!this.isBodyVisible()) {
-                this.needsRefresh = true;
-            }
-            else {
-                if (we && !we.name) {
-                    useCachedEvaluation = true;
-                }
-                await this.tree.updateChildren();
-                useCachedEvaluation = false;
-                if (we instanceof Expression) {
-                    this.tree.reveal(we);
-                }
-            }
-        }));
-        this._register(this.debugService.getViewModel().onDidFocusStackFrame(() => {
-            if (!this.isBodyVisible()) {
-                this.needsRefresh = true;
-                return;
-            }
-            if (!this.watchExpressionsUpdatedScheduler.isScheduled()) {
-                this.watchExpressionsUpdatedScheduler.schedule();
-            }
-        }));
-        this._register(this.debugService.getViewModel().onWillUpdateViews(() => {
-            if (!ignoreViewUpdates) {
-                this.tree.updateChildren();
-            }
-        }));
-        this._register(this.onDidChangeBodyVisibility(visible => {
-            if (visible && this.needsRefresh) {
-                this.watchExpressionsUpdatedScheduler.schedule();
-            }
-        }));
-        let horizontalScrolling;
-        this._register(this.debugService.getViewModel().onDidSelectExpression(e => {
-            const expression = e?.expression;
-            if (expression instanceof Expression || (expression instanceof Variable && e?.settingWatch)) {
-                horizontalScrolling = this.tree.options.horizontalScrolling;
-                if (horizontalScrolling) {
-                    this.tree.updateOptions({ horizontalScrolling: false });
-                }
-                if (expression.name) {
-                    this.tree.rerender(expression);
-                }
-            }
-            else if (!expression && horizontalScrolling !== undefined) {
-                this.tree.updateOptions({ horizontalScrolling: horizontalScrolling });
-                horizontalScrolling = undefined;
-            }
-        }));
-        this._register(this.debugService.getViewModel().onDidEvaluateLazyExpression(async (e) => {
-            if (e instanceof Variable && this.tree.hasNode(e)) {
-                await this.tree.updateChildren(e, false, true);
-                await this.tree.expand(e);
-            }
-        }));
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this.tree.layout(height, width);
-    }
-    focus() {
-        this.tree.domFocus();
-    }
-    collapseAll() {
-        this.tree.collapseAll();
-    }
-    onMouseDblClick(e) {
-        if (e.browserEvent.target.className.indexOf('twistie') >= 0) {
-            return;
-        }
-        const element = e.element;
-        const selectedExpression = this.debugService.getViewModel().getSelectedExpression();
-        if (element instanceof Expression && element !== selectedExpression?.expression) {
-            this.debugService.getViewModel().setSelectedExpression(element, false);
-        }
-        else if (!element) {
-            this.debugService.addWatchExpression();
-        }
-    }
-    onContextMenu(e) {
-        const element = e.element;
-        const selection = this.tree.getSelection();
-        this.watchItemType.set(element instanceof Expression ? 'expression' : element instanceof Variable ? 'variable' : undefined);
-        const actions = [];
-        const attributes = element instanceof Variable ? element.presentationHint?.attributes : undefined;
-        this.variableReadonly.set(!!attributes && attributes.indexOf('readOnly') >= 0 || !!element?.presentationHint?.lazy);
-        createAndFillInContextMenuActions(this.menu, { arg: element, shouldForwardArgs: true }, actions);
-        this.contextMenuService.showContextMenu({
-            getAnchor: () => e.anchor,
-            getActions: () => actions,
-            getActionsContext: () => element && selection.includes(element) ? selection : element ? [element] : [],
-        });
-    }
-};
-WatchExpressionsView = ( __decorate([
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IViewDescriptorService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, IMenuService))
-], WatchExpressionsView));
-class WatchExpressionsDelegate {
-    getHeight(_element) {
-        return 22;
-    }
-    getTemplateId(element) {
-        if (element instanceof Expression) {
-            return WatchExpressionsRenderer.ID;
-        }
-        return VariablesRenderer.ID;
-    }
-}
-function isDebugService(element) {
-    return typeof element.getConfigurationManager === 'function';
-}
-class WatchExpressionsDataSource {
-    hasChildren(element) {
-        return isDebugService(element) || element.hasChildren;
-    }
-    getChildren(element) {
-        if (isDebugService(element)) {
-            const debugService = element;
-            const watchExpressions = debugService.getModel().getWatchExpressions();
-            const viewModel = debugService.getViewModel();
-            return Promise.all(( watchExpressions.map(we => !!we.name && !useCachedEvaluation
-                ? we.evaluate(viewModel.focusedSession, viewModel.focusedStackFrame, 'watch').then(() => we)
-                : Promise.resolve(we))));
-        }
-        return element.getChildren();
-    }
-}
-let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractExpressionsRenderer {
-    constructor(menuService, contextKeyService, debugService, contextViewService) {
-        super(debugService, contextViewService);
-        this.menuService = menuService;
-        this.contextKeyService = contextKeyService;
-    }
-    get templateId() {
-        return WatchExpressionsRenderer.ID;
-    }
-    renderElement(node, index, data) {
-        super.renderExpressionElement(node.element, node, data);
-    }
-    renderExpression(expression, data, highlights) {
-        const text = typeof expression.value === 'string' ? `${expression.name}:` : expression.name;
-        let title;
-        if (expression.type) {
-            title = expression.type === expression.value ?
-                expression.type :
-                `${expression.type}: ${expression.value}`;
-        }
-        else {
-            title = expression.value;
-        }
-        data.label.set(text, highlights, title);
-        renderExpressionValue(expression, data.value, {
-            showChanged: true,
-            maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
-            showHover: true,
-            colorize: true
-        });
-    }
-    getInputBoxOptions(expression, settingValue) {
-        if (settingValue) {
-            return {
-                initialValue: expression.value,
-                ariaLabel: ( localize('typeNewValue', "Type new value")),
-                onFinish: async (value, success) => {
-                    if (success && value) {
-                        const focusedFrame = this.debugService.getViewModel().focusedStackFrame;
-                        if (focusedFrame && (expression instanceof Variable || expression instanceof Expression)) {
-                            await expression.setExpression(value, focusedFrame);
-                            this.debugService.getViewModel().updateViews();
-                        }
-                    }
-                }
-            };
-        }
-        return {
-            initialValue: expression.name ? expression.name : '',
-            ariaLabel: ( localize('watchExpressionInputAriaLabel', "Type watch expression")),
-            placeholder: ( localize('watchExpressionPlaceholder', "Expression to watch")),
-            onFinish: (value, success) => {
-                if (success && value) {
-                    this.debugService.renameWatchExpression(expression.getId(), value);
-                    ignoreViewUpdates = true;
-                    this.debugService.getViewModel().updateViews();
-                    ignoreViewUpdates = false;
-                }
-                else if (!expression.name) {
-                    this.debugService.removeWatchExpressions(expression.getId());
-                }
-            }
-        };
-    }
-    renderActionBar(actionBar, expression) {
-        const contextKeyService = getContextForWatchExpressionMenu(this.contextKeyService, expression);
-        const menu = this.menuService.createMenu(MenuId.DebugWatchContext, contextKeyService);
-        const primary = [];
-        const context = expression;
-        createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
-        actionBar.clear();
-        actionBar.context = context;
-        actionBar.push(primary, { icon: true, label: false });
-    }
-};
-WatchExpressionsRenderer.ID = 'watchexpression';
-WatchExpressionsRenderer = ( __decorate([
-    ( __param(0, IMenuService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IContextViewService))
-], WatchExpressionsRenderer));
-function getContextForWatchExpressionMenu(parentContext, expression) {
-    return parentContext.createOverlay([
-        [CONTEXT_CAN_VIEW_MEMORY.key, expression.memoryReference !== undefined],
-        [CONTEXT_WATCH_ITEM_TYPE.key, 'expression']
-    ]);
-}
-class WatchExpressionsAccessibilityProvider {
-    getWidgetAriaLabel() {
-        return ( localize(
-            { comment: ['Debug is a noun in this context, not a verb.'], key: 'watchAriaTreeLabel' },
-            "Debug Watch Expressions"
-        ));
-    }
-    getAriaLabel(element) {
-        if (element instanceof Expression) {
-            return ( localize('watchExpressionAriaLabel', "{0}, value {1}", element.name, element.value));
-        }
-        return ( localize('watchVariableAriaLabel', "{0}, value {1}", element.name, element.value));
-    }
-}
-class WatchExpressionsDragAndDrop {
-    constructor(debugService) {
-        this.debugService = debugService;
-    }
-    onDragOver(data) {
-        if (!(data instanceof ElementsDragAndDropData)) {
-            return false;
-        }
-        const expressions = data.elements;
-        return expressions.length > 0 && expressions[0] instanceof Expression;
-    }
-    getDragURI(element) {
-        if (!(element instanceof Expression) || element === this.debugService.getViewModel().getSelectedExpression()?.expression) {
-            return null;
-        }
-        return element.getId();
-    }
-    getDragLabel(elements) {
-        if (elements.length === 1) {
-            return elements[0].name;
-        }
-        return undefined;
-    }
-    drop(data, targetElement) {
-        if (!(data instanceof ElementsDragAndDropData)) {
-            return;
-        }
-        const draggedElement = data.elements[0];
-        const watches = this.debugService.getModel().getWatchExpressions();
-        const position = targetElement instanceof Expression ? watches.indexOf(targetElement) : watches.length - 1;
-        this.debugService.moveWatchExpression(draggedElement.getId(), position);
-    }
-}
-registerAction2(class Collapse extends ViewAction {
-    constructor() {
-        super({
-            id: 'watch.collapse',
-            viewId: WATCH_VIEW_ID,
-            title: ( localize('collapse', "Collapse All")),
-            f1: false,
-            icon: Codicon.collapseAll,
-            precondition: CONTEXT_WATCH_EXPRESSIONS_EXIST,
-            menu: {
-                id: MenuId.ViewTitle,
-                order: 30,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
-            }
-        });
-    }
-    runInView(_accessor, view) {
-        view.collapseAll();
-    }
-});
-const ADD_WATCH_ID = 'workbench.debug.viewlet.action.addWatchExpression';
-const ADD_WATCH_LABEL = ( localize('addWatchExpression', "Add Expression"));
-registerAction2(class AddWatchExpressionAction extends Action2 {
-    constructor() {
-        super({
-            id: ADD_WATCH_ID,
-            title: ADD_WATCH_LABEL,
-            f1: false,
-            icon: watchExpressionsAdd,
-            menu: {
-                id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
-            }
-        });
-    }
-    run(accessor) {
-        const debugService = accessor.get(IDebugService);
-        debugService.addWatchExpression();
-    }
-});
-const REMOVE_WATCH_EXPRESSIONS_COMMAND_ID = 'workbench.debug.viewlet.action.removeAllWatchExpressions';
-const REMOVE_WATCH_EXPRESSIONS_LABEL = ( localize('removeAllWatchExpressions', "Remove All Expressions"));
-registerAction2(class RemoveAllWatchExpressionsAction extends Action2 {
-    constructor() {
-        super({
-            id: REMOVE_WATCH_EXPRESSIONS_COMMAND_ID,
-            title: REMOVE_WATCH_EXPRESSIONS_LABEL,
-            f1: false,
-            icon: watchExpressionsRemoveAll,
-            precondition: CONTEXT_WATCH_EXPRESSIONS_EXIST,
-            menu: {
-                id: MenuId.ViewTitle,
-                order: 20,
-                group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
-            }
-        });
-    }
-    run(accessor) {
-        const debugService = accessor.get(IDebugService);
-        debugService.removeWatchExpressions();
-    }
-});
-export { ADD_WATCH_ID, ADD_WATCH_LABEL, REMOVE_WATCH_EXPRESSIONS_COMMAND_ID, REMOVE_WATCH_EXPRESSIONS_LABEL, WatchExpressionsView };

package/dist/vscode/vs/workbench/contrib/debug/browser/welcomeView.js

@@ -1,85 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IDebugService } from '../common/debug.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ViewPane } from '../../../browser/parts/views/viewPane.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IViewDescriptorService } from '../../../common/views.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { DEBUG_START_COMMAND_ID } from './debugCommands.js';
-const debugStartLanguageKey = 'debugStartLanguage';
-const CONTEXT_DEBUG_START_LANGUAGE = ( new RawContextKey(debugStartLanguageKey, undefined));
-const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey('debuggerInterestedInActiveEditor', false));
-let WelcomeView = class WelcomeView extends ViewPane {
-    constructor(options, themeService, keybindingService, contextMenuService, configurationService, contextKeyService, debugService, editorService, instantiationService, viewDescriptorService, openerService, storageSevice, telemetryService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.debugService = debugService;
-        this.editorService = editorService;
-        this.debugStartLanguageContext = CONTEXT_DEBUG_START_LANGUAGE.bindTo(contextKeyService);
-        this.debuggerInterestedContext = CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR.bindTo(contextKeyService);
-        const lastSetLanguage = storageSevice.get(debugStartLanguageKey, 1 );
-        this.debugStartLanguageContext.set(lastSetLanguage);
-        const setContextKey = () => {
-            const editorControl = this.editorService.activeTextEditorControl;
-            if (isCodeEditor(editorControl)) {
-                const model = editorControl.getModel();
-                const language = model ? model.getLanguageId() : undefined;
-                if (language && this.debugService.getAdapterManager().someDebuggerInterestedInLanguage(language)) {
-                    this.debugStartLanguageContext.set(language);
-                    this.debuggerInterestedContext.set(true);
-                    storageSevice.store(debugStartLanguageKey, language, 1 , 1 );
-                    return;
-                }
-            }
-            this.debuggerInterestedContext.set(false);
-        };
-        const disposables = ( new DisposableStore());
-        this._register(disposables);
-        this._register(editorService.onDidActiveEditorChange(() => {
-            disposables.clear();
-            const editorControl = this.editorService.activeTextEditorControl;
-            if (isCodeEditor(editorControl)) {
-                disposables.add(editorControl.onDidChangeModelLanguage(setContextKey));
-            }
-            setContextKey();
-        }));
-        this._register(this.debugService.getAdapterManager().onDidRegisterDebugger(setContextKey));
-        this._register(this.onDidChangeBodyVisibility(visible => {
-            if (visible) {
-                setContextKey();
-            }
-        }));
-        setContextKey();
-        const debugKeybinding = this.keybindingService.lookupKeybinding(DEBUG_START_COMMAND_ID);
-        debugKeybinding ? ` (${debugKeybinding.getLabel()})` : '';
-    }
-    shouldShowWelcome() {
-        return true;
-    }
-};
-WelcomeView.ID = 'workbench.debug.welcome';
-WelcomeView.LABEL = ( localize('run', "Run"));
-WelcomeView = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IDebugService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IInstantiationService)),
-    ( __param(9, IViewDescriptorService)),
-    ( __param(10, IOpenerService)),
-    ( __param(11, IStorageService)),
-    ( __param(12, ITelemetryService))
-], WelcomeView));
-export { WelcomeView };

package/dist/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.js

@@ -1,3 +0,0 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const IExternalUriOpenerService = ( createDecorator('externalUriOpenerService'));
-export { IExternalUriOpenerService };