@codingame/monaco-vscode-debug-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/workbench/contrib/debug/common/nullDebugService.d.ts

@@ -0,0 +1,70 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IDisposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAdapterManager, IBreakpoint, IConfig, IConfigurationManager, IDebugModel, IDebugSession, IDebugSessionOptions, IEnablement, IExceptionBreakpoint, IExpression, ILaunch, IStackFrame, IThread, IViewModel, State } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug";
+import { IDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug.service";
+import type { IDataBreakpointOptions, IFunctionBreakpointOptions, IInstructionBreakpointOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debugModel";
+import { DebugVisualizer } from "./debugVisualizers.js";
+import { IDebugVisualizerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debugVisualizers.service";
+export declare class NullDebugService implements IDebugService {
+    readonly _serviceBrand: undefined;
+    readonly state = State.Inactive;
+    readonly initializingOptions: undefined;
+    readonly onDidChangeState: Event<any>;
+    readonly onWillNewSession: Event<any>;
+    readonly onDidNewSession: Event<any>;
+    readonly onDidEndSession: Event<any>;
+    getConfigurationManager(): IConfigurationManager;
+    getAdapterManager(): IAdapterManager;
+    getModel(): IDebugModel;
+    getViewModel(): IViewModel;
+    focusStackFrame(_focusedStackFrame: IStackFrame | undefined, _thread?: IThread, _session?: IDebugSession, _options?: {
+        explicit?: boolean;
+        preserveFocus?: boolean;
+        sideBySide?: boolean;
+        pinned?: boolean;
+    }): Promise<void>;
+    canSetBreakpointsIn(): boolean;
+    addBreakpoints(): Promise<IBreakpoint[]>;
+    updateBreakpoints(): Promise<void>;
+    enableOrDisableBreakpoints(_enable: boolean, _breakpoint?: IEnablement): Promise<void>;
+    setBreakpointsActivated(_activated: boolean): Promise<void>;
+    removeBreakpoints(_id?: string | string[]): Promise<void>;
+    addFunctionBreakpoint(_opts?: IFunctionBreakpointOptions, _id?: string): void;
+    updateFunctionBreakpoint(_id: string, _update: {
+        name?: string;
+        hitCondition?: string;
+        condition?: string;
+    }): Promise<void>;
+    removeFunctionBreakpoints(_id?: string): Promise<void>;
+    addDataBreakpoint(_opts: IDataBreakpointOptions): Promise<void>;
+    updateDataBreakpoint(_id: string, _update: {
+        hitCondition?: string;
+        condition?: string;
+    }): Promise<void>;
+    removeDataBreakpoints(_id?: string): Promise<void>;
+    addInstructionBreakpoint(_opts: IInstructionBreakpointOptions): Promise<void>;
+    removeInstructionBreakpoints(_instructionReference?: string, _offset?: number, _address?: bigint): Promise<void>;
+    setExceptionBreakpointCondition(_breakpoint: IExceptionBreakpoint, _condition: string | undefined): Promise<void>;
+    setExceptionBreakpointsForSession(_session: IDebugSession, _filters: DebugProtocol.ExceptionBreakpointsFilter[]): void;
+    sendAllBreakpoints(_session?: IDebugSession): Promise<void>;
+    sendBreakpoints(_modelUri: URI, _sourceModified?: boolean, _session?: IDebugSession): Promise<void>;
+    addWatchExpression(_name?: string): void;
+    renameWatchExpression(_id: string, _newName: string): void;
+    moveWatchExpression(_id: string, _position: number): void;
+    removeWatchExpressions(_id?: string): void;
+    startDebugging(_launch: ILaunch | undefined, _configOrName?: IConfig | string, _options?: IDebugSessionOptions, _saveBeforeStart?: boolean): Promise<boolean>;
+    restartSession(_session: IDebugSession, _restartData?: unknown): Promise<void>;
+    stopSession(_session: IDebugSession | undefined, _disconnect?: boolean, _suspend?: boolean): Promise<void>;
+    sourceIsNotAvailable(): void;
+    runTo(): Promise<void>;
+}
+export declare class NullDebugVisualizerService implements IDebugVisualizerService {
+    readonly _serviceBrand: undefined;
+    getApplicableFor(): Promise<IReference<DebugVisualizer[]>>;
+    register(): IDisposable;
+    registerTree(): IDisposable;
+    getVisualizedNodeFor(): Promise<undefined>;
+    getVisualizedChildren(): Promise<IExpression[]>;
+    editTreeItem(): Promise<void>;
+}

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

@@ -0,0 +1,137 @@
+
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { State } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug';
+
+const nullViewModel = {
+    getId() { return 'root'; },
+    focusedSession: undefined,
+    focusedThread: undefined,
+    focusedStackFrame: undefined,
+    setVisualizedExpression() { },
+    getVisualizedExpression() { return undefined; },
+    getSelectedExpression() { return undefined; },
+    setSelectedExpression() { },
+    updateViews() { },
+    isMultiSessionView() { return false; },
+    onDidFocusSession: Event.None,
+    onDidFocusThread: Event.None,
+    onDidFocusStackFrame: Event.None,
+    onDidSelectExpression: Event.None,
+    onDidEvaluateLazyExpression: Event.None,
+    onDidChangeVisualization: Event.None,
+    onWillUpdateViews: Event.None,
+    evaluateLazyExpression(_expression) { },
+};
+const nullDebugModel = {
+    getId() { return 'root'; },
+    getSession() { return undefined; },
+    getSessions() { return []; },
+    getBreakpoints() { return []; },
+    areBreakpointsActivated() { return false; },
+    getFunctionBreakpoints() { return []; },
+    getDataBreakpoints() { return []; },
+    getExceptionBreakpoints() { return []; },
+    getExceptionBreakpointsForSession() { return []; },
+    getInstructionBreakpoints() { return []; },
+    getWatchExpressions() { return []; },
+    registerBreakpointModes() { },
+    getBreakpointModes() { return []; },
+    onDidChangeBreakpoints: Event.None,
+    onDidChangeCallStack: Event.None,
+    onDidChangeWatchExpressions: Event.None,
+    onDidChangeWatchExpressionValue: Event.None,
+    async fetchCallstack() { },
+};
+const nullConfigurationManager = {
+    selectedConfiguration: {
+        launch: undefined,
+        getConfig: () => Promise.resolve(undefined),
+        name: undefined,
+        type: undefined,
+    },
+    async selectConfiguration() { },
+    getLaunches() { return []; },
+    getLaunch() { return undefined; },
+    getAllConfigurations() { return []; },
+    removeRecentDynamicConfigurations() { },
+    getRecentDynamicConfigurations() { return []; },
+    onDidSelectConfiguration: Event.None,
+    onDidChangeConfigurationProviders: Event.None,
+    hasDebugConfigurationProvider() { return false; },
+    async getDynamicProviders() { return []; },
+    async getDynamicConfigurationsByType() { return []; },
+    registerDebugConfigurationProvider() { return Disposable.None; },
+    unregisterDebugConfigurationProvider() { },
+    async resolveConfigurationByProviders() { return undefined; },
+};
+const nullAdapterManager = {
+    onDidRegisterDebugger: Event.None,
+    hasEnabledDebuggers() { return false; },
+    async getDebugAdapterDescriptor() { return undefined; },
+    getDebuggerLabel() { return undefined; },
+    someDebuggerInterestedInLanguage() { return false; },
+    getDebugger() { return undefined; },
+    async activateDebuggers() { },
+    registerDebugAdapterFactory() { return Disposable.None; },
+    createDebugAdapter() { return undefined; },
+    registerDebugAdapterDescriptorFactory() { return Disposable.None; },
+    unregisterDebugAdapterDescriptorFactory() { },
+    async substituteVariables(_debugType, _folder, config) { return config; },
+    async runInTerminal() { return undefined; },
+    getEnabledDebugger() { return undefined; },
+    async guessDebugger() { return undefined; },
+    get onDidDebuggersExtPointRead() { return Event.None; },
+};
+class NullDebugService {
+    constructor() {
+        this.state = State.Inactive;
+        this.initializingOptions = undefined;
+        this.onDidChangeState = Event.None;
+        this.onWillNewSession = Event.None;
+        this.onDidNewSession = Event.None;
+        this.onDidEndSession = Event.None;
+    }
+    getConfigurationManager() { return nullConfigurationManager; }
+    getAdapterManager() { return nullAdapterManager; }
+    getModel() { return nullDebugModel; }
+    getViewModel() { return nullViewModel; }
+    async focusStackFrame(_focusedStackFrame, _thread, _session, _options) { }
+    canSetBreakpointsIn() { return false; }
+    async addBreakpoints() { return []; }
+    async updateBreakpoints() { }
+    async enableOrDisableBreakpoints(_enable, _breakpoint) { }
+    async setBreakpointsActivated(_activated) { }
+    async removeBreakpoints(_id) { }
+    addFunctionBreakpoint(_opts, _id) { }
+    async updateFunctionBreakpoint(_id, _update) { }
+    async removeFunctionBreakpoints(_id) { }
+    async addDataBreakpoint(_opts) { }
+    async updateDataBreakpoint(_id, _update) { }
+    async removeDataBreakpoints(_id) { }
+    async addInstructionBreakpoint(_opts) { }
+    async removeInstructionBreakpoints(_instructionReference, _offset, _address) { }
+    async setExceptionBreakpointCondition(_breakpoint, _condition) { }
+    setExceptionBreakpointsForSession(_session, _filters) { }
+    async sendAllBreakpoints(_session) { }
+    async sendBreakpoints(_modelUri, _sourceModified, _session) { }
+    addWatchExpression(_name) { }
+    renameWatchExpression(_id, _newName) { }
+    moveWatchExpression(_id, _position) { }
+    removeWatchExpressions(_id) { }
+    async startDebugging(_launch, _configOrName, _options, _saveBeforeStart) { return false; }
+    async restartSession(_session, _restartData) { }
+    async stopSession(_session, _disconnect, _suspend) { }
+    sourceIsNotAvailable() { }
+    async runTo() { }
+}
+class NullDebugVisualizerService {
+    async getApplicableFor() { return { object: [], dispose() { } }; }
+    register() { return Disposable.None; }
+    registerTree() { return Disposable.None; }
+    async getVisualizedNodeFor() { return undefined; }
+    async getVisualizedChildren() { return []; }
+    async editTreeItem() { }
+}
+
+export { NullDebugService, NullDebugVisualizerService };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands.js

@@ -8,7 +8,7 @@ import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/w
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 
 const COPY_NOTEBOOK_VARIABLE_VALUE_ID = "workbench.debug.viewlet.action.copyWorkspaceVariableValue";
-const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localize(14437, "Copy Value"));
+const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localize(16576, "Copy Value"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
@@ -28,7 +28,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "_executeNotebookVariableProvider",
-            title: ( localize(14438, "Execute Notebook Variable Provider")),
+            title: ( localize(16577, "Execute Notebook Variable Provider")),
             f1: false
         });
     }