@opensumi/ide-debug 2.21.13 → 2.22.0

package/src/browser/breakpoint/breakpoint-manager.ts

@@ -0,0 +1,348 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  Emitter,
+  Event,
+  URI,
+  isUndefined,
+  StorageProvider,
+  IStorage,
+  STORAGE_NAMESPACE,
+  IReporterService,
+} from '@opensumi/ide-core-browser';
+import { Deferred } from '@opensumi/ide-core-common';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol';
+
+import { BreakpointsChangeEvent, DEBUG_REPORT_NAME, IDebugBreakpoint } from '../../common';
+import { DebugModel } from '../editor';
+import { MarkerManager, Marker } from '../markers';
+
+import { DebugExceptionBreakpoint, BREAKPOINT_KIND } from './breakpoint-marker';
+
+export interface ExceptionBreakpointsChangeEvent {
+  filters: string[];
+}
+
+export interface SelectedBreakpoint {
+  breakpoint?: IDebugBreakpoint;
+  model: DebugModel;
+}
+
+@Injectable()
+export class BreakpointManager extends MarkerManager<IDebugBreakpoint> {
+  protected readonly owner = 'breakpoint';
+  private _selectedBreakpoint: SelectedBreakpoint;
+
+  private defaultExceptionFilter: DebugProtocol.ExceptionBreakpointsFilter[] = [];
+  private exceptionFilterValue: { [key: string]: boolean } | undefined;
+  private _affected = new Set<string>();
+
+  @Autowired(StorageProvider)
+  private readonly storageProvider: StorageProvider;
+
+  @Autowired(IReporterService)
+  private readonly reporterService: IReporterService;
+
+  getKind(): string {
+    return BREAKPOINT_KIND;
+  }
+
+  get selectedBreakpoint() {
+    return this._selectedBreakpoint;
+  }
+
+  set selectedBreakpoint(value: SelectedBreakpoint) {
+    this._selectedBreakpoint = value;
+  }
+
+  get affected() {
+    return Array.from(this._affected.values());
+  }
+
+  protected breakpointsDeffered: Deferred<void> | null = null;
+
+  protected readonly onDidChangeBreakpointsEmitter = new Emitter<BreakpointsChangeEvent>();
+  readonly onDidChangeBreakpoints: Event<BreakpointsChangeEvent> = this.onDidChangeBreakpointsEmitter.event;
+  protected readonly onDidChangeExceptionsBreakpointsEmitter = new Emitter<ExceptionBreakpointsChangeEvent>();
+  readonly onDidChangeExceptionsBreakpoints: Event<ExceptionBreakpointsChangeEvent> =
+    this.onDidChangeExceptionsBreakpointsEmitter.event;
+
+  public setBpDeffered(): this {
+    this.breakpointsDeffered = new Deferred();
+    return this;
+  }
+
+  public resolveBpDeffered(): void {
+    if (this.breakpointsDeffered) {
+      this.breakpointsDeffered.resolve();
+    }
+  }
+
+  public promiseBpDeffered(): Promise<void> {
+    if (this.breakpointsDeffered) {
+      return this.breakpointsDeffered.promise;
+    } else {
+      return Promise.resolve();
+    }
+  }
+
+  setMarkers(uri: URI, owner: string, newMarkers: IDebugBreakpoint[]): Marker<IDebugBreakpoint>[] {
+    const result = super.setMarkers(uri, owner, newMarkers);
+    const added: IDebugBreakpoint[] = [];
+    const removed: IDebugBreakpoint[] = [];
+    const changed: IDebugBreakpoint[] = [];
+    const oldMarkers = new Map(result.map(({ data }) => [data.id, data] as [string, IDebugBreakpoint]));
+    const ids = new Set<string>();
+
+    for (const newMarker of newMarkers) {
+      ids.add(newMarker.id);
+      if (oldMarkers.has(newMarker.id)) {
+        changed.push(newMarker);
+      } else {
+        added.push(newMarker);
+      }
+    }
+    for (const [id, data] of oldMarkers.entries()) {
+      if (!ids.has(id)) {
+        removed.push(data);
+      }
+    }
+    this.onDidChangeBreakpointsEmitter.fire({ affected: [uri], added, removed, changed });
+    return result;
+  }
+
+  getBreakpoint(uri: URI, filter: number | Partial<monaco.IPosition> | undefined): IDebugBreakpoint | undefined {
+    if (typeof filter === 'number') {
+      filter = { lineNumber: filter };
+    }
+    return this.getBreakpoints(uri, filter)[0];
+  }
+
+  getBreakpoints(uri?: URI, filter?: Partial<monaco.IPosition>): IDebugBreakpoint[] {
+    let dataFilter: ((breakpoint: IDebugBreakpoint) => boolean) | undefined;
+    if (filter) {
+      dataFilter = (breakpoint: IDebugBreakpoint) => {
+        if (
+          (filter.lineNumber && breakpoint.raw.line !== filter.lineNumber) ||
+          (filter.column && breakpoint.raw.column !== filter.column)
+        ) {
+          return false;
+        }
+        return true;
+      };
+    }
+    return this.findMarkers({
+      uri,
+      dataFilter,
+    }).map((marker) => marker.data);
+  }
+
+  setBreakpoints(uri: URI, breakpoints: IDebugBreakpoint[]): void {
+    if (breakpoints.length > 0) {
+      this._affected.add(uri.toString());
+    } else {
+      this._affected.delete(uri.toString());
+    }
+    this.setMarkers(
+      uri,
+      this.owner,
+      breakpoints.sort((a, b) => a.raw.line - b.raw.line),
+    );
+  }
+
+  addBreakpoint(breakpoint: IDebugBreakpoint): boolean {
+    const uri = new URI(breakpoint.uri);
+    const breakpoints = this.getBreakpoints(uri);
+    const existed = breakpoints.find(
+      ({ raw }) => raw.line === breakpoint.raw.line && raw.column === breakpoint.raw.column,
+    );
+    this.reporterService.point(DEBUG_REPORT_NAME?.DEBUG_BREAKPOINT, 'add');
+    if (!existed) {
+      this.setBreakpoints(uri, [...breakpoints, breakpoint]);
+      return true;
+    }
+    return false;
+  }
+
+  delBreakpoint(breakpoint: IDebugBreakpoint): boolean {
+    const uri = URI.parse(breakpoint.uri);
+    const breakpoints = this.getBreakpoints(uri);
+    const index = breakpoints.findIndex((bp) => bp.id === breakpoint.id);
+    if (index > -1) {
+      breakpoints.splice(index, 1);
+      this.setBreakpoints(uri, ([] as IDebugBreakpoint[]).concat(breakpoints));
+      return true;
+    }
+    return false;
+  }
+
+  clearBreakpoints() {
+    const affected = new Set<string>();
+    const breakpoints = this.getBreakpoints();
+    breakpoints.map((b) => affected.add(b.uri));
+    this.cleanAllMarkers();
+    this._affected.clear();
+    this.onDidChangeBreakpointsEmitter.fire({
+      affected: Array.from(affected.values()).map((str) => URI.parse(str)),
+      added: [],
+      removed: breakpoints,
+      changed: [],
+    });
+  }
+
+  updateBreakpoint(breakpoint: IDebugBreakpoint, statusUpdated = false) {
+    const uri = URI.parse(breakpoint.uri);
+    this.onDidChangeBreakpointsEmitter.fire({
+      affected: [uri],
+      added: [],
+      removed: [],
+      changed: [breakpoint],
+      statusUpdated,
+    });
+  }
+
+  updateBreakpoints(breakpoints: IDebugBreakpoint[], statusUpdated = false) {
+    const uriStrings = new Set<string>();
+    breakpoints.forEach((breakpoint) => {
+      uriStrings.add(breakpoint.uri);
+    });
+    this.onDidChangeBreakpointsEmitter.fire({
+      affected: Array.from(uriStrings.values()).map((v) => URI.parse(v)),
+      added: [],
+      removed: [],
+      changed: breakpoints,
+      statusUpdated,
+    });
+  }
+
+  enableAllBreakpoints(enabled: boolean): void {
+    for (const uriString of this.getUris()) {
+      let didChange = false;
+      const uri = new URI(uriString);
+      const markers = this.findMarkers({ uri });
+      for (const marker of markers) {
+        if (marker.data.enabled !== enabled) {
+          marker.data.enabled = enabled;
+          didChange = true;
+        }
+      }
+      if (didChange) {
+        this.fireOnDidChangeMarkers(uri);
+      }
+    }
+  }
+
+  protected _breakpointsEnabled = true;
+  get breakpointsEnabled(): boolean {
+    return this._breakpointsEnabled;
+  }
+  set breakpointsEnabled(breakpointsEnabled: boolean) {
+    if (this._breakpointsEnabled !== breakpointsEnabled) {
+      this._breakpointsEnabled = breakpointsEnabled;
+      for (const uri of this.getUris()) {
+        this.fireOnDidChangeMarkers(new URI(uri));
+      }
+      this.updateBreakpoints(this.getBreakpoints());
+    }
+  }
+
+  async load(): Promise<void> {
+    const storage: IStorage = await this.storageProvider(STORAGE_NAMESPACE.DEBUG);
+    const data = storage.get<BreakpointManager.Data>('breakpoints', {
+      breakpointsEnabled: true,
+      breakpoints: {},
+      defaultExceptionFilter: [],
+    });
+    this._breakpointsEnabled = data!.breakpointsEnabled;
+    // eslint-disable-next-line guard-for-in
+    for (const uri in data!.breakpoints) {
+      this.setBreakpoints(
+        new URI(uri),
+        data!.breakpoints[uri].map((v) => Object.assign(v, { status: new Map() })),
+      );
+    }
+    this.defaultExceptionFilter = data.defaultExceptionFilter || [];
+    this.exceptionFilterValue = {};
+    this.defaultExceptionFilter.forEach((item) => {
+      this.exceptionFilterValue![item.filter] = !!item.default;
+    });
+  }
+
+  async save(): Promise<void> {
+    const data: BreakpointManager.Data = {
+      breakpointsEnabled: this.breakpointsEnabled,
+      breakpoints: {},
+      defaultExceptionFilter: this.defaultExceptionFilter,
+    };
+    const uris = this.getUris();
+    for (const uri of uris) {
+      data.breakpoints[uri] = this.findMarkers({ uri: new URI(uri) }).map((marker) => marker.data);
+    }
+    const storage: IStorage = await this.storageProvider(STORAGE_NAMESPACE.DEBUG);
+    await storage.set('breakpoints', data);
+  }
+
+  clearAllStatus(sessionId: string) {
+    const breakpoints = this.getBreakpoints();
+    breakpoints.forEach((breakpoint) => {
+      breakpoint.status.delete(sessionId);
+    });
+    this.updateBreakpoints(breakpoints);
+  }
+
+  /**
+   * 设置异常断点元信息
+   * @param session
+   * @param filter
+   */
+  setExceptionBreakpoints(filters: DebugProtocol.ExceptionBreakpointsFilter[]) {
+    this.defaultExceptionFilter = filters;
+    for (const item of filters) {
+      if (!isUndefined(this.exceptionFilterValue)) {
+        this.updateExceptionBreakpoints(
+          item.filter,
+          isUndefined(this.exceptionFilterValue[item.filter]) ? !!item.default : this.exceptionFilterValue[item.filter],
+        );
+      } else {
+        this.updateExceptionBreakpoints(item.filter, !!item.default);
+      }
+    }
+  }
+
+  /**
+   * 获取异常断点元信息
+   * @param session
+   */
+  getExceptionBreakpoints(): DebugExceptionBreakpoint[] {
+    return this.defaultExceptionFilter.map((breakpoint) => ({
+      ...breakpoint,
+      default: (this.exceptionFilterValue || {})[breakpoint.filter] || false,
+    }));
+  }
+
+  /**
+   * 通知DebugSession更新Exception配置
+   * @param exceptionBreakpoints
+   */
+  updateExceptionBreakpoints(filter: string, value: boolean) {
+    if (isUndefined(this.exceptionFilterValue)) {
+      this.exceptionFilterValue = {};
+    }
+    this.exceptionFilterValue[filter] = value;
+
+    const filters = this.defaultExceptionFilter
+      .filter((exp) => (this.exceptionFilterValue || {})[exp.filter])
+      .map((exp) => exp.filter);
+    this.onDidChangeExceptionsBreakpointsEmitter.fire({ filters });
+  }
+}
+
+export namespace BreakpointManager {
+  export interface Data {
+    breakpointsEnabled: boolean;
+    breakpoints: {
+      [uri: string]: IDebugBreakpoint[];
+    };
+    defaultExceptionFilter: DebugExceptionBreakpoint[];
+  }
+}

package/src/browser/breakpoint/breakpoint-marker.ts

@@ -0,0 +1,70 @@
+import btoa from 'btoa';
+
+import { URI } from '@opensumi/ide-core-common';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol/lib/debugProtocol';
+
+import { IRuntimeBreakpoint, IDebugBreakpoint } from '../../common';
+import { Marker } from '../markers';
+
+export const BREAKPOINT_KIND = 'breakpoint';
+
+function generateId(uri: string, line: number, column = 1) {
+  return btoa(`${uri}:${line}:${column}`);
+}
+
+export namespace DebugBreakpoint {
+  export function create(uri: URI, data: DebugProtocol.SourceBreakpoint, enabled = true): IDebugBreakpoint {
+    return {
+      id: generateId(uri.toString(), data.line, data.column),
+      uri: uri.toString(),
+      enabled,
+      status: new Map<string, DebugProtocol.Breakpoint>(),
+      raw: {
+        column: undefined,
+        condition: undefined,
+        hitCondition: undefined,
+        logMessage: undefined,
+        ...data,
+      },
+    };
+  }
+}
+
+export interface IExceptionBreakpoint {
+  label: string;
+  filter: string;
+  default?: boolean;
+}
+
+export type DebugExceptionBreakpoint = IExceptionBreakpoint;
+
+export function isDebugBreakpoint(
+  breakpoint: IDebugBreakpoint | DebugExceptionBreakpoint,
+): breakpoint is IDebugBreakpoint {
+  return !!breakpoint && !!(breakpoint as IDebugBreakpoint).raw;
+}
+
+export function getStatus(breakpoint: IRuntimeBreakpoint) {
+  return Array.from(breakpoint.status.values()).filter((b) => b.verified)[0];
+}
+
+export function isRuntimeBreakpoint(breakpoint: IDebugBreakpoint): breakpoint is IRuntimeBreakpoint {
+  const status = getStatus(breakpoint);
+  return !!(status && status.verified);
+}
+
+export function isDebugExceptionBreakpoint(
+  breakpoint: IDebugBreakpoint | DebugExceptionBreakpoint,
+): breakpoint is DebugExceptionBreakpoint {
+  return breakpoint && !!(breakpoint as DebugExceptionBreakpoint).filter;
+}
+
+export interface BreakpointMarker extends Marker<IDebugBreakpoint> {
+  kind: 'breakpoint';
+}
+
+export namespace BreakpointMarker {
+  export function is(node: Marker<object>): node is BreakpointMarker {
+    return 'kind' in node && node.kind === BREAKPOINT_KIND;
+  }
+}

package/src/browser/breakpoint/index.ts

@@ -0,0 +1,3 @@
+export * from './breakpoint-manager';
+export * from './breakpoint-marker';
+export * from './breakpoint-decoration';

package/src/browser/components/debug-action/index.module.less

@@ -0,0 +1,73 @@
+.debug_action {
+  opacity: 0.9;
+  cursor: pointer;
+  pointer-events: all;
+  text-align: center;
+  width: 16px;
+  height: 16px;
+  min-width: 16px;
+  line-height: 16px;
+  &::before {
+    font-size: 16px;
+  }
+  &:active {
+    transform: scale(1.1);
+  }
+  &::not(:focus) {
+    border: 1px solid transparent;
+  }
+  &.mod_disabled {
+    opacity: 0.5;
+    user-select: none;
+    pointer-events: none;
+  }
+}
+
+.icon-size {
+  font-size: 16px;
+}
+
+.start {
+  color: var(--debugIcon-startForeground);
+  .icon-size;
+}
+
+.continue {
+  color: var(--debugIcon-continueForeground);
+  .icon-size;
+}
+
+.step-in {
+  color: var(--debugIcon-stepIntoForeground);
+  .icon-size;
+}
+
+.step-out {
+  color: var(--debugIcon-stepOutForeground);
+  .icon-size;
+}
+
+.stop {
+  color: var(--debugIcon-stopForeground);
+  .icon-size;
+}
+
+.pause {
+  color: var(--debugIcon-pauseForeground);
+  .icon-size;
+}
+
+.disconnect {
+  color: var(--debugIcon-disconnectForeground);
+  .icon-size;
+}
+
+.reload {
+  color: var(--debugIcon-restartForeground);
+  .icon-size;
+}
+
+.step {
+  color: var(--debugIcon-stepOverForeground);
+  .icon-size;
+}

package/src/browser/components/debug-action/index.tsx

@@ -0,0 +1,40 @@
+import cls from 'classnames';
+import React from 'react';
+
+import { getIcon } from '@opensumi/ide-core-browser';
+
+import styles from './index.module.less';
+
+export interface DebugActionProps {
+  icon: string;
+  label: string;
+  run?: () => any;
+  enabled?: boolean;
+  color?: string;
+  className?: string;
+}
+
+export const DebugAction = ({
+  icon,
+  label,
+  run,
+  enabled,
+  className,
+  ...restProps
+}: DebugActionProps & React.HtmlHTMLAttributes<HTMLDivElement>) => {
+  const noop = () => {};
+  return (
+    <div
+      {...restProps}
+      className={cls(
+        styles.debug_action,
+        styles[icon],
+        getIcon(icon) || icon,
+        typeof enabled === 'boolean' && !enabled && styles.mod_disabled,
+        className,
+      )}
+      title={label}
+      onClick={run || noop}
+    ></div>
+  );
+};

package/src/browser/components/debug-exception-widget.less

@@ -0,0 +1,42 @@
+.exception_widget_container {
+  overflow: hidden;
+  width: 100%;
+  background-color: var(--debugExceptionWidget-background);
+  border-top: 1px solid var(--debugExceptionWidget-border);
+  border-bottom: 1px solid var(--debugExceptionWidget-border);
+  &:focus {
+    outline: 1px solid var(--focusBorder);
+    outline-offset: -1px;
+  }
+
+  .exception_widget {
+    padding: 6px 10px;
+    white-space: pre-wrap;
+    user-select: text;
+    -webkit-user-select: text;
+  }
+
+  .exception_widget .title {
+    display: flex;
+  }
+
+  .exception_widget .title .label {
+    font-weight: bold;
+    display: flex;
+    align-items: center;
+  }
+
+  .exception_widget .title .actions {
+    flex: 1;
+  }
+
+  .exception_widget .stack_trace {
+    margin-top: 0.5em;
+  }
+
+  .exception_widget .stack_trace a {
+    text-decoration: underline;
+    cursor: pointer;
+    color: currentColor;
+  }
+}

package/src/browser/components/floating-click-widget/index.module.less

@@ -0,0 +1,5 @@
+.floating_click_widget {
+  position: absolute;
+  right: 50px;
+  bottom: 30px;
+}

package/src/browser/components/floating-click-widget/index.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+
+import { Button } from '@opensumi/ide-components';
+import { localize } from '@opensumi/ide-core-browser';
+import { useInjectable } from '@opensumi/ide-core-browser';
+
+import { DebugConfigurationService } from '../../view/configuration/debug-configuration.service';
+
+import styles from './index.module.less';
+
+export const FloatingClickWidget = (_: React.HtmlHTMLAttributes<HTMLDivElement>) => {
+  const { addConfiguration } = useInjectable<DebugConfigurationService>(DebugConfigurationService);
+
+  return (
+    <div className={styles.floating_click_widget}>
+      <Button onClick={addConfiguration} size='large'>
+        {localize('debug.action.add.configuration')}
+      </Button>
+    </div>
+  );
+};

package/src/browser/components/index.ts

@@ -0,0 +1 @@
+export * from './debug-action';

package/src/browser/contextkeys/debug-call-stack-item-type-key.ts

@@ -0,0 +1,4 @@
+import { IContextKey } from '@opensumi/ide-core-browser';
+
+export const DebugCallStackItemTypeKey = Symbol('DebugCallStackItemTypeKey');
+export type DebugCallStackItemTypeKey = IContextKey<'session' | 'thread' | 'stackFrame'>;

package/src/browser/contextkeys/debug-contextkey.service.ts

@@ -0,0 +1,54 @@
+import { Optional, Injectable, Autowired } from '@opensumi/di';
+import { IContextKeyService, IContextKey, IScopedContextKeyService } from '@opensumi/ide-core-browser';
+
+import { DebugState } from '../../common';
+
+import {
+  CONTEXT_IN_DEBUG_REPL,
+  CONTEXT_IN_DEBUG_CONSOLE,
+  CONTEXT_IN_DEBUG_MODE,
+  CONTEXT_DEBUG_STATE,
+  CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT,
+  CONTEXT_SET_VARIABLE_SUPPORTED,
+  CONTEXT_RESTART_FRAME_SUPPORTED,
+  CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT,
+  CONTEXT_CAN_VIEW_MEMORY,
+  CONTEXT_EXCEPTION_WIDGET_VISIBLE,
+} from './../../common/constants';
+
+@Injectable()
+export class DebugContextKey {
+  @Autowired(IContextKeyService)
+  private readonly globalContextKeyService: IContextKeyService;
+
+  private _contextKeyService: IScopedContextKeyService | undefined;
+
+  public readonly contextInDebugRepl: IContextKey<boolean>;
+  public readonly contextInDebugConsole: IContextKey<boolean>;
+  public readonly contextInDdebugMode: IContextKey<boolean>;
+  public readonly contextDebugState: IContextKey<keyof typeof DebugState>;
+  public readonly contextVariableEvaluateNamePresent: IContextKey<boolean>;
+  public readonly contextSetVariableSupported: IContextKey<boolean>;
+  public readonly contextRestartFrameSupported: IContextKey<boolean>;
+  public readonly contextDebugProtocolVariableMenu: IContextKey<string>;
+  public readonly contextCanViewMemory: IContextKey<boolean>;
+  public readonly contextExceptionWidgetVisible: IContextKey<boolean>;
+
+  constructor(@Optional() dom?: HTMLElement) {
+    this._contextKeyService = this.globalContextKeyService.createScoped(dom);
+    this.contextInDebugRepl = CONTEXT_IN_DEBUG_REPL.bind(this.contextKeyScoped);
+    this.contextInDebugConsole = CONTEXT_IN_DEBUG_CONSOLE.bind(this.contextKeyScoped);
+    this.contextInDdebugMode = CONTEXT_IN_DEBUG_MODE.bind(this.contextKeyScoped);
+    this.contextDebugState = CONTEXT_DEBUG_STATE.bind(this.contextKeyScoped);
+    this.contextVariableEvaluateNamePresent = CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT.bind(this.contextKeyScoped);
+    this.contextSetVariableSupported = CONTEXT_SET_VARIABLE_SUPPORTED.bind(this.contextKeyScoped);
+    this.contextRestartFrameSupported = CONTEXT_RESTART_FRAME_SUPPORTED.bind(this.contextKeyScoped);
+    this.contextDebugProtocolVariableMenu = CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT.bind(this.contextKeyScoped);
+    this.contextCanViewMemory = CONTEXT_CAN_VIEW_MEMORY.bind(this.contextKeyScoped);
+    this.contextExceptionWidgetVisible = CONTEXT_EXCEPTION_WIDGET_VISIBLE.bind(this._contextKeyService);
+  }
+
+  public get contextKeyScoped(): IScopedContextKeyService {
+    return this._contextKeyService!;
+  }
+}

package/src/browser/contextkeys/index.ts

@@ -0,0 +1 @@
+export * from './debug-call-stack-item-type-key';