@codingame/monaco-vscode-api 2.0.3-improve-modularity.1 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/workbench/contrib/debug/common/debugVisualizers.js

@@ -0,0 +1,164 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { isDefined } from '../../../../base/common/types.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { CONTEXT_VARIABLE_NAME, CONTEXT_VARIABLE_VALUE, CONTEXT_VARIABLE_TYPE } from './debug.js';
+import { getContextForVariable } from './debugContext.js';
+import { Variable, Scope } from './debugModel.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+const IDebugVisualizerService = ( createDecorator('debugVisualizerService'));
+class DebugVisualizer {
+    get name() {
+        return this.viz.name;
+    }
+    get iconPath() {
+        return this.viz.iconPath;
+    }
+    get iconClass() {
+        return this.viz.iconClass;
+    }
+    constructor(handle, viz) {
+        this.handle = handle;
+        this.viz = viz;
+    }
+    async resolve(token) {
+        return this.viz.visualization ??= await this.handle.resolveDebugVisualizer(this.viz, token);
+    }
+    async execute() {
+        await this.handle.executeDebugVisualizerCommand(this.viz.id);
+    }
+}
+let DebugVisualizerService = class DebugVisualizerService {
+    constructor(contextKeyService, extensionService, logService) {
+        this.contextKeyService = contextKeyService;
+        this.extensionService = extensionService;
+        this.logService = logService;
+        this.handles = ( new Map());
+        this.didActivate = ( new Map());
+        this.registrations = [];
+        visualizersExtensionPoint.setHandler((_, { added, removed }) => {
+            this.registrations = this.registrations.filter(r => !( removed.some(e => ExtensionIdentifier.equals(e.description.identifier, r.extensionId))));
+            added.forEach(e => this.processExtensionRegistration(e.description));
+        });
+    }
+    async getApplicableFor(variable, token) {
+        const threadId = variable.getThreadId();
+        if (threadId === undefined) {
+            return { object: [], dispose: () => { } };
+        }
+        const context = {
+            sessionId: variable.getSession()?.getId() || '',
+            containerId: variable.parent.getId(),
+            threadId,
+            variable: {
+                name: variable.name,
+                value: variable.value,
+                type: variable.type,
+                evaluateName: variable.evaluateName,
+                variablesReference: variable.reference || 0,
+                indexedVariables: variable.indexedVariables,
+                memoryReference: variable.memoryReference,
+                namedVariables: variable.namedVariables,
+                presentationHint: variable.presentationHint,
+            }
+        };
+        for (let p = variable; p instanceof Variable; p = p.parent) {
+            if (p.parent instanceof Scope) {
+                context.frameId = p.parent.stackFrame.frameId;
+            }
+        }
+        const overlay = getContextForVariable(this.contextKeyService, variable, [
+            [CONTEXT_VARIABLE_NAME.key, variable.name],
+            [CONTEXT_VARIABLE_VALUE.key, variable.value],
+            [CONTEXT_VARIABLE_TYPE.key, variable.type],
+        ]);
+        const maybeVisualizers = await Promise.all(( this.registrations.map(async (registration) => {
+            if (!overlay.contextMatchesRules(registration.expr)) {
+                return;
+            }
+            let prom = this.didActivate.get(registration.id);
+            if (!prom) {
+                prom = this.extensionService.activateByEvent(`onDebugVisualizer:${registration.id}`);
+                this.didActivate.set(registration.id, prom);
+            }
+            await prom;
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const handle = this.handles.get(toKey(registration.extensionId, registration.id));
+            return handle && { handle, result: await handle.provideDebugVisualizers(context, token) };
+        })));
+        const ref = {
+            object: maybeVisualizers.filter(isDefined).flatMap(v => ( v.result.map(r => ( new DebugVisualizer(v.handle, r))))),
+            dispose: () => {
+                for (const viz of maybeVisualizers) {
+                    viz?.handle.disposeDebugVisualizers(( viz.result.map(r => r.id)));
+                }
+            },
+        };
+        if (token.isCancellationRequested) {
+            ref.dispose();
+        }
+        return ref;
+    }
+    register(handle) {
+        const key = toKey(handle.extensionId, handle.id);
+        this.handles.set(key, handle);
+        return toDisposable(() => this.handles.delete(key));
+    }
+    processExtensionRegistration(ext) {
+        const viz = ext.contributes?.debugVisualizers;
+        if (!(viz instanceof Array)) {
+            return;
+        }
+        for (const { when, id } of viz) {
+            try {
+                const expr = ContextKeyExpr.deserialize(when);
+                if (expr) {
+                    this.registrations.push({ expr, id, extensionId: ext.identifier });
+                }
+            }
+            catch (e) {
+                this.logService.error(`Error processing debug visualizer registration from extension '${ext.identifier.value}'`, e);
+            }
+        }
+    }
+};
+DebugVisualizerService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, ILogService))
+], DebugVisualizerService));
+const toKey = (extensionId, id) => `${ExtensionIdentifier.toKey(extensionId)}\0${id}`;
+const visualizersExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'debugVisualizers',
+    jsonSchema: {
+        type: 'array',
+        items: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Name of the debug visualizer'
+                },
+                when: {
+                    type: 'string',
+                    description: 'Condition when the debug visualizer is applicable'
+                }
+            },
+            required: ['id', 'when']
+        }
+    },
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            if (contrib.id) {
+                result.push(`onDebugVisualizer:${contrib.id}`);
+            }
+        }
+    }
+}));
+export { DebugVisualizer, DebugVisualizerService, IDebugVisualizerService };

package/vscode/src/vs/workbench/contrib/debug/common/disassemblyViewInput.js

@@ -1,5 +1,12 @@
 import { EditorInput } from '../../../common/editor/editorInput.js';
 import { localizeWithPath } from '../../../../nls.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+const DisassemblyEditorIcon = registerIcon('disassembly-editor-label-icon', Codicon.debug, ( localizeWithPath(
+    'vs/workbench/contrib/debug/common/disassemblyViewInput',
+    'disassemblyEditorLabelIcon',
+    'Icon of the disassembly editor label.'
+)));
 class DisassemblyViewInput extends EditorInput {
     constructor() {
         super(...arguments);
@@ -22,6 +29,9 @@ class DisassemblyViewInput extends EditorInput {
             "Disassembly"
         ));
     }
+    getIcon() {
+        return DisassemblyEditorIcon;
+    }
     matches(other) {
         return other instanceof DisassemblyViewInput;
     }

package/vscode/src/vs/workbench/contrib/debug/common/replModel.js

@@ -0,0 +1,285 @@
+import { Emitter } from '../../../../base/common/event.js';
+import Severity from '../../../../base/common/severity.js';
+import { isObject, isString } from '../../../../base/common/types.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ExpressionContainer } from './debugModel.js';
+const MAX_REPL_LENGTH = 10000;
+let topReplElementCounter = 0;
+const getUniqueId = () => `topReplElement:${topReplElementCounter++}`;
+class ReplOutputElement {
+    constructor(session, id, value, severity, sourceData, expression) {
+        this.session = session;
+        this.id = id;
+        this.value = value;
+        this.severity = severity;
+        this.sourceData = sourceData;
+        this.expression = expression;
+        this._count = 1;
+        this._onDidChangeCount = ( new Emitter());
+    }
+    toString(includeSource = false) {
+        let valueRespectCount = this.value;
+        for (let i = 1; i < this.count; i++) {
+            valueRespectCount += (valueRespectCount.endsWith('\n') ? '' : '\n') + this.value;
+        }
+        const sourceStr = (this.sourceData && includeSource) ? ` ${this.sourceData.source.name}` : '';
+        return valueRespectCount + sourceStr;
+    }
+    getId() {
+        return this.id;
+    }
+    getChildren() {
+        return this.expression?.getChildren() || Promise.resolve([]);
+    }
+    set count(value) {
+        this._count = value;
+        this._onDidChangeCount.fire();
+    }
+    get count() {
+        return this._count;
+    }
+    get onDidChangeCount() {
+        return this._onDidChangeCount.event;
+    }
+    get hasChildren() {
+        return !!this.expression?.hasChildren;
+    }
+}
+class ReplVariableElement {
+    constructor(expression, severity, sourceData) {
+        this.expression = expression;
+        this.severity = severity;
+        this.sourceData = sourceData;
+        this.id = generateUuid();
+        this.hasChildren = expression.hasChildren;
+    }
+    getChildren() {
+        return this.expression.getChildren();
+    }
+    toString() {
+        return ( this.expression.toString());
+    }
+    getId() {
+        return this.id;
+    }
+}
+class RawObjectReplElement {
+    static { this.MAX_CHILDREN = 1000; }
+    constructor(id, name, valueObj, sourceData, annotation) {
+        this.id = id;
+        this.name = name;
+        this.valueObj = valueObj;
+        this.sourceData = sourceData;
+        this.annotation = annotation;
+    }
+    getId() {
+        return this.id;
+    }
+    get value() {
+        if (this.valueObj === null) {
+            return 'null';
+        }
+        else if (Array.isArray(this.valueObj)) {
+            return `Array[${this.valueObj.length}]`;
+        }
+        else if (isObject(this.valueObj)) {
+            return 'Object';
+        }
+        else if (isString(this.valueObj)) {
+            return `"${this.valueObj}"`;
+        }
+        return String(this.valueObj) || '';
+    }
+    get hasChildren() {
+        return (Array.isArray(this.valueObj) && this.valueObj.length > 0) || (isObject(this.valueObj) && Object.getOwnPropertyNames(this.valueObj).length > 0);
+    }
+    evaluateLazy() {
+        throw new Error('Method not implemented.');
+    }
+    getChildren() {
+        let result = [];
+        if (Array.isArray(this.valueObj)) {
+            result = ( this.valueObj.slice(0, RawObjectReplElement.MAX_CHILDREN)
+                .map((v, index) => ( new RawObjectReplElement(`${this.id}:${index}`, String(index), v))));
+        }
+        else if (isObject(this.valueObj)) {
+            result = ( Object.getOwnPropertyNames(this.valueObj).slice(0, RawObjectReplElement.MAX_CHILDREN)
+                .map((key, index) => ( new RawObjectReplElement(`${this.id}:${index}`, key, this.valueObj[key]))));
+        }
+        return Promise.resolve(result);
+    }
+    toString() {
+        return `${this.name}\n${this.value}`;
+    }
+}
+class ReplEvaluationInput {
+    constructor(value) {
+        this.value = value;
+        this.id = generateUuid();
+    }
+    toString() {
+        return this.value;
+    }
+    getId() {
+        return this.id;
+    }
+}
+class ReplEvaluationResult extends ExpressionContainer {
+    get available() {
+        return this._available;
+    }
+    constructor(originalExpression) {
+        super(undefined, undefined, 0, generateUuid());
+        this.originalExpression = originalExpression;
+        this._available = true;
+    }
+    async evaluateExpression(expression, session, stackFrame, context) {
+        const result = await super.evaluateExpression(expression, session, stackFrame, context);
+        this._available = result;
+        return result;
+    }
+    toString() {
+        return `${this.value}`;
+    }
+}
+class ReplGroup {
+    static { this.COUNTER = 0; }
+    constructor(name, autoExpand, sourceData) {
+        this.name = name;
+        this.autoExpand = autoExpand;
+        this.sourceData = sourceData;
+        this.children = [];
+        this.ended = false;
+        this.id = `replGroup:${ReplGroup.COUNTER++}`;
+    }
+    get hasChildren() {
+        return true;
+    }
+    getId() {
+        return this.id;
+    }
+    toString(includeSource = false) {
+        const sourceStr = (includeSource && this.sourceData) ? ` ${this.sourceData.source.name}` : '';
+        return this.name + sourceStr;
+    }
+    addChild(child) {
+        const lastElement = this.children.length ? this.children[this.children.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.addChild(child);
+        }
+        else {
+            this.children.push(child);
+        }
+    }
+    getChildren() {
+        return this.children;
+    }
+    end() {
+        const lastElement = this.children.length ? this.children[this.children.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.end();
+        }
+        else {
+            this.ended = true;
+        }
+    }
+    get hasEnded() {
+        return this.ended;
+    }
+}
+function areSourcesEqual(first, second) {
+    if (!first && !second) {
+        return true;
+    }
+    if (first && second) {
+        return first.column === second.column && first.lineNumber === second.lineNumber && ( first.source.uri.toString()) === ( second.source.uri.toString());
+    }
+    return false;
+}
+class ReplModel {
+    constructor(configurationService) {
+        this.configurationService = configurationService;
+        this.replElements = [];
+        this._onDidChangeElements = ( new Emitter());
+        this.onDidChangeElements = this._onDidChangeElements.event;
+    }
+    getReplElements() {
+        return this.replElements;
+    }
+    async addReplExpression(session, stackFrame, name) {
+        this.addReplElement(( new ReplEvaluationInput(name)));
+        const result = ( new ReplEvaluationResult(name));
+        await result.evaluateExpression(name, session, stackFrame, 'repl');
+        this.addReplElement(result);
+    }
+    appendToRepl(session, { output, expression, sev, source }) {
+        const clearAnsiSequence = '\u001b[2J';
+        const clearAnsiIndex = output.lastIndexOf(clearAnsiSequence);
+        if (clearAnsiIndex !== -1) {
+            this.removeReplExpressions();
+            this.appendToRepl(session, { output: ( localizeWithPath(
+                'vs/workbench/contrib/debug/common/replModel',
+                'consoleCleared',
+                "Console was cleared"
+            )), sev: Severity.Ignore });
+            output = output.substring(clearAnsiIndex + clearAnsiSequence.length);
+        }
+        if (expression) {
+            this.addReplElement(output
+                ? ( new ReplOutputElement(session, getUniqueId(), output, sev, source, expression))
+                : ( new ReplVariableElement(expression, sev, source)));
+            return;
+        }
+        const previousElement = this.replElements.length ? this.replElements[this.replElements.length - 1] : undefined;
+        if (previousElement instanceof ReplOutputElement && previousElement.severity === sev) {
+            const config = this.configurationService.getValue('debug');
+            if (previousElement.value === output && areSourcesEqual(previousElement.sourceData, source) && config.console.collapseIdenticalLines) {
+                previousElement.count++;
+                return;
+            }
+            if (!previousElement.value.endsWith('\n') && !previousElement.value.endsWith('\r\n') && previousElement.count === 1) {
+                this.replElements[this.replElements.length - 1] = ( new ReplOutputElement(session, getUniqueId(), previousElement.value + output, sev, source));
+                this._onDidChangeElements.fire();
+                return;
+            }
+        }
+        const element = ( new ReplOutputElement(session, getUniqueId(), output, sev, source));
+        this.addReplElement(element);
+    }
+    startGroup(name, autoExpand, sourceData) {
+        const group = ( new ReplGroup(name, autoExpand, sourceData));
+        this.addReplElement(group);
+    }
+    endGroup() {
+        const lastElement = this.replElements[this.replElements.length - 1];
+        if (lastElement instanceof ReplGroup) {
+            lastElement.end();
+        }
+    }
+    addReplElement(newElement) {
+        const lastElement = this.replElements.length ? this.replElements[this.replElements.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.addChild(newElement);
+        }
+        else {
+            this.replElements.push(newElement);
+            if (this.replElements.length > MAX_REPL_LENGTH) {
+                this.replElements.splice(0, this.replElements.length - MAX_REPL_LENGTH);
+            }
+        }
+        this._onDidChangeElements.fire();
+    }
+    removeReplExpressions() {
+        if (this.replElements.length > 0) {
+            this.replElements = [];
+            this._onDidChangeElements.fire();
+        }
+    }
+    clone() {
+        const newRepl = ( new ReplModel(this.configurationService));
+        newRepl.replElements = this.replElements.slice();
+        return newRepl;
+    }
+}
+export { RawObjectReplElement, ReplEvaluationInput, ReplEvaluationResult, ReplGroup, ReplModel, ReplOutputElement, ReplVariableElement };